| `task()`
| Creates a Task with the given name and adds it to this project.
|===

== Build Script structure

The Build script is composed of `{ ... }`, a special object in both Groovy and Kotlin.
This object is called a _lambda_ in Kotlin or a _closure_ in Groovy.

    %0 = stablehlo.convert %arg0 : (tensor<1x3xi8>) -> tensor<1x3xf32>
    return %0 : tensor<1x3xf32>
  }
// CHECK: @uniform_dequantize_0
}

// -----

// Tests that a quantized dot_general op is composed when both operands are
// actiavations.

// CHECK-LABEL: dot_general_with_two_activations
// CHECK-SAME: %[[ARG_0:.*]]: tensor<8x16x16xf32>
// CHECK-SAME: %[[ARG_1:.*]]: tensor<8x16x4xf32>
module {

image::tutorial/intellij-idea-ide.png[]

Open the `settings.gradle(.kts)` and `build.gradle(.kts)` files in the IDE:

image::tutorial/intellij-idea-open.png[]

== Step 6. Understanding the Settings file
A project is composed of one or more subprojects (sometimes called modules).

Gradle reads the `settings.gradle(.kts)` file to figure out which subprojects comprise a project build.

Take a look at the file in your project:

    ```

`OAuth2PasswordRequestForm` is a class dependency that declares a form body with:

* The `username`.
* The `password`.
* An optional `scope` field as a big string, composed of strings separated by spaces.
* An optional `grant_type`.

!!! tip
    The OAuth2 spec actually *requires* a field `grant_type` with a fixed value of `password`, but `OAuth2PasswordRequestForm` doesn't enforce it.

    2. Operations that don't have a kernel defined for the device.

    This pass is conservative in that it will mark all ops for outside compilation
    that can not be compiled for the device.  Exceptions for this are added for ops
    that will be rewritten or decomposed before compiling on device.


    For example, tf_device.cluster op with an unsupported op, tf.UnsupportedOp:

    ```mlir

		return nil, nil
	}
	return vr.Value()
}

// decimal composes or decomposes a decimal value to and from individual parts.
// There are four parts: a boolean negative flag, a form byte with three possible states
// (finite=0, infinite=1, NaN=2), a base-2 big-endian integer
// coefficient (also known as a significand) as a []byte, and an int32 exponent.

	gateways sets.String, configs []config.Config,
) []*filterChainOpts {
	if !listenPort.Protocol.IsTLS() {
		return nil
	}
	actualWildcard, _ := getActualWildcardAndLocalHost(node)
	// TLS matches are composed of runtime and static predicates.
	// Static predicates can be evaluated during the generation of the config. Examples: gateway, source labels, etc.

```

This will select tests that have ```label.CustomSetup``` only. It will **not** select tests that have both ```label.CustomSetup```
and ```label.Postsubmit```.

### Running Tests on CI

Istio's CI/CD system is composed of 2 parts:

Tool | Description |
---|---

class {{CLASS}} final : public tensorflow::XlaCompiledCpuFunction {
 public:
  // Number of input arguments for the compiled computation.
  static constexpr size_t kNumArgs = {{ARG_NUM}};

  static constexpr size_t kNumResults = {{RESULT_NUM}};

  // Number of variables for the compiled computation.
  static constexpr size_t kNumVariables = {{VARIABLE_NUM}};

---

Common examples of CPU bound operations are things that require complex math processing.

For example:

* **Audio** or **image processing**.
* **Computer vision**: an image is composed of millions of pixels, each pixel has 3 values / colors, processing that normally requires computing something on those pixels, all at the same time.