Lines Matching refs:matrix

23 A matrix type is a scalar type with an underlying *element type*, a constant
25 element type, rows, and columns are the same type. A value of a matrix type
33 Currently, the element type of a matrix is only permitted to be one of the
47 of the *typedef* must be a valid matrix element type. The
51 type of the *typedef* becomes a matrix type with the given dimensions and an
66 A value of matrix type can be converted to another matrix type if the number of
68 element type of the result type. The result is a matrix where each element is
71 A value of any real type (as in C2x 6.2.5p17) can be converted to a matrix type
72 if it can be converted to the element type of the matrix. The result is a
73 matrix where all elements are the converted original value.
86 * If both operands are of matrix type, no arithmetic conversion is performed.
87 * If one operand is of matrix type and the other operand is of a real type,
88   convert the real type operand to the matrix type
94 An expression of the form ``E1 [E2] [E3]``, where ``E1`` has matrix type ``cv
95 M``, is a matrix element access expression.  Let ``T`` be the element type
103 ``T`` and is the value of the element at the given row and column in the matrix.
106 the matrix.
108 Programs containing a single subscript expression into a matrix are ill-formed.
111 ``postfix-expression [expression]`` to access columns of a matrix. We think
115 builtins to extract rows and columns from a matrix. This makes the operations
122 and subtraction, while the ``*`` operator performs matrix multiplication.
123 ``+``, ``-``, ``*``, and ``/`` can also be used with a matrix and a scalar
124 value, applying the operation to each element of the matrix.
132 * ``BIN_OP`` is one of ``+`` or ``-``, one of ``M1`` and ``M2`` is of matrix
133   type, and the other is of matrix type or real type; or
134 * ``BIN_OP`` is ``*``, one of ``M1`` and ``M2`` is of matrix type, and the
136 * ``BIN_OP`` is ``/``, ``M1`` is of matrix type, and ``M2`` is of a real type:
140 * ``M1`` and ``M2`` shall be of the same matrix type.
142   columns and row is the number of rows in the matrix type:
151 Given the expression ``M1 * M2`` where ``M1`` and ``M2`` are of matrix type:
156 * The resulting type, ``MTy``, is a matrix type with the common element type,
174 All operations on matrix types match the behavior of the element type with
178 operations on matrix types match the behavior of the elementwise operations
184 as part of a matrix operation are considered intermediate operations, and their
195 Each matrix type supports a collection of builtin expressions that look like
208 ``M2 __builtin_matrix_transpose(M1 matrix)``
210 **Remarks**: The return type is a cv-unqualified matrix type that has the same
214 **Returns**: A matrix ``Res`` equivalent to the code below, where ``col`` refers to the
224       Res[C][R] = matrix[R][C];
233 **Remarks**: The return type is a cv-unqualified matrix type with an element
238 **Returns**: A matrix ``Res`` equivalent to:
250 ``void __builtin_matrix_column_major_store(M matrix, T *ptr, size_t columnStride)``
254 **Remarks**: The type ``T`` is the const-unqualified version of the matrix
264       ptr[R] = matrix[R][C];
273 where M is a matrix type? We don’t support this anywhere else, but it’s
286 The elements of a  value of a matrix type are laid out in column-major order
290 contraction of those operations (e.g. *-ffp-contract=matrix*).
292 TODO: Specify how matrix values are passed to functions.