Lines Matching +full:x +full:- +full:alpha
8 * http://www.apache.org/licenses/LICENSE-2.0
28 * every row in a user-backed allocation must be aligned by this amount.
67 * Flags that can control RenderScript behavior on a per-context level.
80 int8_t x, y;
83 : x(initX), y(initY) {} in Byte2()
84 Byte2() : x(0), y(0) {} in Byte2()
89 int8_t x, y, z;
92 : x(initX), y(initY), z(initZ) {} in Byte3()
93 Byte3() : x(0), y(0), z(0) {} in Byte3()
98 int8_t x, y, z, w;
101 : x(initX), y(initY), z(initZ), w(initW) {} in Byte4()
102 Byte4() : x(0), y(0), z(0), w(0) {} in Byte4()
107 uint8_t x, y;
110 : x(initX), y(initY) {} in UByte2()
111 UByte2() : x(0), y(0) {} in UByte2()
116 uint8_t x, y, z;
119 : x(initX), y(initY), z(initZ) {} in UByte3()
120 UByte3() : x(0), y(0), z(0) {} in UByte3()
125 uint8_t x, y, z, w;
128 : x(initX), y(initY), z(initZ), w(initW) {} in UByte4()
129 UByte4() : x(0), y(0), z(0), w(0) {} in UByte4()
134 int16_t x, y;
137 : x(initX), y(initY) {} in Short2()
138 Short2() : x(0), y(0) {} in Short2()
143 int16_t x, y, z;
146 : x(initX), y(initY), z(initZ) {} in Short3()
147 Short3() : x(0), y(0), z(0) {} in Short3()
152 int16_t x, y, z, w;
155 : x(initX), y(initY), z(initZ), w(initW) {} in Short4()
156 Short4() : x(0), y(0), z(0), w(0) {} in Short4()
161 uint16_t x, y;
164 : x(initX), y(initY) {} in UShort2()
165 UShort2() : x(0), y(0) {} in UShort2()
170 uint16_t x, y, z;
173 : x(initX), y(initY), z(initZ) {} in UShort3()
174 UShort3() : x(0), y(0), z(0) {} in UShort3()
179 uint16_t x, y, z, w;
182 : x(initX), y(initY), z(initZ), w(initW) {} in UShort4()
183 UShort4() : x(0), y(0), z(0), w(0) {} in UShort4()
188 int x, y;
191 : x(initX), y(initY) {} in Int2()
192 Int2() : x(0), y(0) {} in Int2()
197 int x, y, z;
200 : x(initX), y(initY), z(initZ) {} in Int3()
201 Int3() : x(0), y(0), z(0) {} in Int3()
206 int x, y, z, w;
209 : x(initX), y(initY), z(initZ), w(initW) {} in Int4()
210 Int4() : x(0), y(0), z(0), w(0) {} in Int4()
215 uint32_t x, y;
218 : x(initX), y(initY) {} in UInt2()
219 UInt2() : x(0), y(0) {} in UInt2()
224 uint32_t x, y, z;
227 : x(initX), y(initY), z(initZ) {} in UInt3()
228 UInt3() : x(0), y(0), z(0) {} in UInt3()
233 uint32_t x, y, z, w;
236 : x(initX), y(initY), z(initZ), w(initW) {} in UInt4()
237 UInt4() : x(0), y(0), z(0), w(0) {} in UInt4()
242 int64_t x, y;
245 : x(initX), y(initY) {} in Long2()
246 Long2() : x(0), y(0) {} in Long2()
251 int64_t x, y, z;
254 : x(initX), y(initY), z(initZ) {} in Long3()
255 Long3() : x(0), y(0), z(0) {} in Long3()
260 int64_t x, y, z, w;
263 : x(initX), y(initY), z(initZ), w(initW) {} in Long4()
264 Long4() : x(0), y(0), z(0), w(0) {} in Long4()
269 uint64_t x, y;
272 : x(initX), y(initY) {} in ULong2()
273 ULong2() : x(0), y(0) {} in ULong2()
278 uint64_t x, y, z;
281 : x(initX), y(initY), z(initZ) {} in ULong3()
282 ULong3() : x(0), y(0), z(0) {} in ULong3()
287 uint64_t x, y, z, w;
290 : x(initX), y(initY), z(initZ), w(initW) {} in ULong4()
291 ULong4() : x(0), y(0), z(0), w(0) {} in ULong4()
296 float x, y;
299 : x(initX), y(initY) {} in Float2()
300 Float2() : x(0), y(0) {} in Float2()
305 float x, y, z;
308 : x(initX), y(initY), z(initZ) {} in Float3()
309 Float3() : x(0.f), y(0.f), z(0.f) {} in Float3()
314 float x, y, z, w;
317 : x(initX), y(initY), z(initZ), w(initW) {} in Float4()
318 Float4() : x(0.f), y(0.f), z(0.f), w(0.f) {} in Float4()
323 double x, y;
326 : x(initX), y(initY) {} in Double2()
327 Double2() : x(0), y(0) {} in Double2()
332 double x, y, z;
335 : x(initX), y(initY), z(initZ) {} in Double3()
336 Double3() : x(0), y(0), z(0) {} in Double3()
341 double x, y, z, w;
344 : x(initX), y(initY), z(initZ), w(initW) {} in Double4()
345 Double4() : x(0), y(0), z(0), w(0) {} in Double4()
702 * @param[in] xoff X offset of region to update in this Allocation
714 * @param[in] xoff X offset of region to copy from this Allocation
725 * @param[in] xoff X offset of region to update in this Allocation
730 * @param[in] dataXoff X offset of region to copy from in data
738 * @param[in] xoff X offset of region to update in this Allocation
757 * @param[in] xoff X offset of region to update in this Allocation
778 * @param[in] xoff X offset of region to update in this Allocation
791 * @param[in] xoff X offset of region to update in this Allocation
798 * @param[in] dataXoff X offset of region in data to copy from
810 * @param[in] xoff X offset of region to update in this Allocation
869 * @param[in] x Width in Elements of the Allocation
875 size_t x, size_t y,
881 * @param[in] stride optional parameter. when non-NULL, will contain
893 * - A single float value (equivalent to a float in a kernel)
894 * - A four-element float vector (equivalent to a float4 in a kernel)
895 * - An unsigned 32-bit integer (equivalent to an unsigned int in a kernel)
896 * - A single signed 8-bit integer (equivalent to a char in a kernel)
903 * use with a Sampler should use bitmap-derived Elements such as
914 * multiple sub-elements, such as a collection of floats, float2,
916 * sub-elements otherwise.
917 * @return number of sub-elements
924 * For complex Elements, this returns the sub-element at a given index.
925 * @param[in] index index of sub-element
926 * @return sub-element
931 * For complex Elements, this returns the name of the sub-element at a given
933 * @param[in] index index of sub-element
934 * @return name of sub-element
939 * For complex Elements, this returns the size of the sub-element at a given
941 * @param[in] index index of sub-element
942 * @return size of sub-element
947 * Returns the location of a sub-element within a complex Element.
948 * @param[in] index index of sub-element
1454 if ((v & (v - 1)) != 0) { in align()
1455 // ALOGE("Non-power-of-two alignment: %zu", v); in align()
1459 while ((mPos & (v - 1)) != 0) { in align()
1524 add((uint32_t) (uintptr_t) obj->getID()); in add()
1535 * A Type always includes an Element and an X dimension. A Type may be
1538 * only a given X dimension and a Type with the same X dimension but Y = 1 are
1585 * Returns the X dimension of the Allocation.
1586 * @return X dimension of the allocation
1637 return mElementCount * mElement->getSizeBytes(); in getSizeBytes()
1644 * @param[in] dimX X dimension
1728 return mAllocation->getType(); in getType()
1740 …* The parent class for all user-defined scripts. This is intended to be used by auto-generated cod…
1764 * r,g,b values are use as normalized x,y,z coordinates into a 3D
1818 * SGEMV performs one of the matrix-vector operations
1819 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
1821 * Details: http://www.netlib.org/lapack/explore-html/db/d58/sgemv_8f.html
1824 * @param alpha The scalar alpha.
1826 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
1827 * @param incX The increment for the elements of vector x, must be larger than zero.
1833 float alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1837 * DGEMV performs one of the matrix-vector operations
1838 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
1840 * Details: http://www.netlib.org/lapack/explore-html/dc/da8/dgemv_8f.html
1843 * @param alpha The scalar alpha.
1845 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
1846 * @param incX The increment for the elements of vector x, must be larger than zero.
1852 double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1856 * CGEMV performs one of the matrix-vector operations
1857 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
1859 * Details: http://www.netlib.org/lapack/explore-html/d4/d8a/cgemv_8f.html
1862 * @param alpha The scalar alpha.
1864 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
1865 * @param incX The increment for the elements of vector x, must be larger than zero.
1871 Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1875 * ZGEMV performs one of the matrix-vector operations
1876 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
1878 * Details: http://www.netlib.org/lapack/explore-html/db/d40/zgemv_8f.html
1881 * @param alpha The scalar alpha.
1883 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
1884 * @param incX The increment for the elements of vector x, must be larger than zero.
1890 Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1894 * SGBMV performs one of the matrix-vector operations
1895 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
1897 * Details: http://www.netlib.org/lapack/explore-html/d6/d46/sgbmv_8f.html
1901 * example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
1903 * for j in range(max(0, i-kl), min(i+ku+1, n)):
1904 * b[i, j-i+kl] = a[i, j]
1907 * @param KL The number of sub-diagonals of the matrix A.
1908 * @param KU The number of super-diagonals of the matrix A.
1909 * @param alpha The scalar alpha.
1911 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
1912 * @param incX The increment for the elements of vector x, must be larger than zero.
1918 … int KL, int KU, float alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1922 * DGBMV performs one of the matrix-vector operations
1923 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
1925 * Details: http://www.netlib.org/lapack/explore-html/d2/d3f/dgbmv_8f.html
1929 * example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
1931 * for j in range(max(0, i-kl), min(i+ku+1, n)):
1932 * b[i, j-i+kl] = a[i, j]
1935 * @param KL The number of sub-diagonals of the matrix A.
1936 * @param KU The number of super-diagonals of the matrix A.
1937 * @param alpha The scalar alpha.
1939 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
1940 * @param incX The increment for the elements of vector x, must be larger than zero.
1946 int KL, int KU, double alpha, const sp<Allocation>& A, const sp<Allocation>& X,
1950 * CGBMV performs one of the matrix-vector operations
1951 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
1953 * Details: http://www.netlib.org/lapack/explore-html/d0/d75/cgbmv_8f.html
1957 * example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
1959 * for j in range(max(0, i-kl), min(i+ku+1, n)):
1960 * b[i, j-i+kl] = a[i, j]
1963 * @param KL The number of sub-diagonals of the matrix A.
1964 * @param KU The number of super-diagonals of the matrix A.
1965 * @param alpha The scalar alpha.
1967 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
1968 * @param incX The increment for the elements of vector x, must be larger than zero.
1974 int KL, int KU, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
1978 * ZGBMV performs one of the matrix-vector operations
1979 * y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
1981 * Details: http://www.netlib.org/lapack/explore-html/d9/d46/zgbmv_8f.html
1985 * example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
1987 * for j in range(max(0, i-kl), min(i+ku+1, n)):
1988 * b[i, j-i+kl] = a[i, j]
1991 * @param KL The number of sub-diagonals of the matrix A.
1992 * @param KU The number of super-diagonals of the matrix A.
1993 * @param alpha The scalar alpha.
1995 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
1996 * @param incX The increment for the elements of vector x, must be larger than zero.
2002 … int KL, int KU, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
2006 * STRMV performs one of the matrix-vector operations
2007 * x := A*x or x := A**T*x
2009 * Details: http://www.netlib.org/lapack/explore-html/de/d45/strmv_8f.html
2015 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2016 * @param incX The increment for the elements of vector x, must be larger than zero.
2019 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2022 * DTRMV performs one of the matrix-vector operations
2023 * x := A*x or x := A**T*x
2025 * Details: http://www.netlib.org/lapack/explore-html/dc/d7e/dtrmv_8f.html
2031 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2032 * @param incX The increment for the elements of vector x, must be larger than zero.
2035 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2038 * CTRMV performs one of the matrix-vector operations
2039 * x := A*x or x := A**T*x or x := A**H*x
2041 * Details: http://www.netlib.org/lapack/explore-html/df/d78/ctrmv_8f.html
2047 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2048 * @param incX The increment for the elements of vector x, must be larger than zero.
2051 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2054 * ZTRMV performs one of the matrix-vector operations
2055 * x := A*x or x := A**T*x or x := A**H*x
2057 * Details: http://www.netlib.org/lapack/explore-html/d0/dd1/ztrmv_8f.html
2063 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2064 * @param incX The increment for the elements of vector x, must be larger than zero.
2067 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2070 * STBMV performs one of the matrix-vector operations
2071 * x := A*x or x := A**T*x
2073 * Details: http://www.netlib.org/lapack/explore-html/d6/d7d/stbmv_8f.html
2077 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2080 * b[i, j-i] = a[i, j]
2085 * @param K The number of off-diagonals of the matrix A
2087 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2088 * @param incX The increment for the elements of vector x, must be larger than zero.
2091 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2094 * DTBMV performs one of the matrix-vector operations
2095 * x := A*x or x := A**T*x
2097 * Details: http://www.netlib.org/lapack/explore-html/df/d29/dtbmv_8f.html
2101 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2104 * b[i, j-i] = a[i, j]
2109 * @param K The number of off-diagonals of the matrix A
2111 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2112 * @param incX The increment for the elements of vector x, must be larger than zero.
2115 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2118 * CTBMV performs one of the matrix-vector operations
2119 * x := A*x or x := A**T*x or x := A**H*x
2121 * Details: http://www.netlib.org/lapack/explore-html/d3/dcd/ctbmv_8f.html
2125 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2128 * b[i, j-i] = a[i, j]
2133 * @param K The number of off-diagonals of the matrix A
2135 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2136 * @param incX The increment for the elements of vector x, must be larger than zero.
2139 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2142 * ZTBMV performs one of the matrix-vector operations
2143 * x := A*x or x := A**T*x or x := A**H*x
2145 * Details: http://www.netlib.org/lapack/explore-html/d3/d39/ztbmv_8f.html
2149 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2152 * b[i, j-i] = a[i, j]
2157 * @param K The number of off-diagonals of the matrix A
2159 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2160 * @param incX The increment for the elements of vector x, must be larger than zero.
2163 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2166 * STPMV performs one of the matrix-vector operations
2167 * x := A*x or x := A**T*x
2169 * Details: http://www.netlib.org/lapack/explore-html/db/db1/stpmv_8f.html
2183 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2184 * @param incX The increment for the elements of vector x, must be larger than zero.
2187 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2190 * DTPMV performs one of the matrix-vector operations
2191 * x := A*x or x := A**T*x
2193 * Details: http://www.netlib.org/lapack/explore-html/dc/dcd/dtpmv_8f.html
2207 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2208 * @param incX The increment for the elements of vector x, must be larger than zero.
2211 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2214 * CTPMV performs one of the matrix-vector operations
2215 * x := A*x or x := A**T*x or x := A**H*x
2217 * Details: http://www.netlib.org/lapack/explore-html/d4/dbb/ctpmv_8f.html
2231 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2232 * @param incX The increment for the elements of vector x, must be larger than zero.
2235 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2238 * ZTPMV performs one of the matrix-vector operations
2239 * x := A*x or x := A**T*x or x := A**H*x
2241 * Details: http://www.netlib.org/lapack/explore-html/d2/d9e/ztpmv_8f.html
2255 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2256 * @param incX The increment for the elements of vector x, must be larger than zero.
2259 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2263 * A*x = b or A**T*x = b
2265 * Details: http://www.netlib.org/lapack/explore-html/d0/d2a/strsv_8f.html
2271 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2272 * @param incX The increment for the elements of vector x, must be larger than zero.
2275 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2279 * A*x = b or A**T*x = b
2281 * Details: http://www.netlib.org/lapack/explore-html/d6/d96/dtrsv_8f.html
2287 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2288 * @param incX The increment for the elements of vector x, must be larger than zero.
2291 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2295 * A*x = b or A**T*x = b or A**H*x = b
2297 * Details: http://www.netlib.org/lapack/explore-html/d4/dc8/ctrsv_8f.html
2303 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2304 * @param incX The increment for the elements of vector x, must be larger than zero.
2307 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2311 * A*x = b or A**T*x = b or A**H*x = b
2313 * Details: http://www.netlib.org/lapack/explore-html/d1/d2f/ztrsv_8f.html
2319 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2320 * @param incX The increment for the elements of vector x, must be larger than zero.
2323 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2327 * A*x = b or A**T*x = b
2329 * Details: http://www.netlib.org/lapack/explore-html/d0/d1f/stbsv_8f.html
2333 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2336 * b[i, j-i] = a[i, j]
2341 * @param K The number of off-diagonals of the matrix A
2343 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2344 * @param incX The increment for the elements of vector x, must be larger than zero.
2347 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2351 * A*x = b or A**T*x = b
2353 * Details: http://www.netlib.org/lapack/explore-html/d4/dcf/dtbsv_8f.html
2357 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2360 * b[i, j-i] = a[i, j]
2365 * @param K The number of off-diagonals of the matrix A
2367 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2368 * @param incX The increment for the elements of vector x, must be larger than zero.
2371 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2375 * A*x = b or A**T*x = b or A**H*x = b
2377 * Details: http://www.netlib.org/lapack/explore-html/d9/d5f/ctbsv_8f.html
2381 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2384 * b[i, j-i] = a[i, j]
2389 * @param K The number of off-diagonals of the matrix A
2391 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2392 * @param incX The increment for the elements of vector x, must be larger than zero.
2395 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2399 * A*x = b or A**T*x = b or A**H*x = b
2401 * Details: http://www.netlib.org/lapack/explore-html/d4/d5a/ztbsv_8f.html
2405 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2408 * b[i, j-i] = a[i, j]
2413 * @param K The number of off-diagonals of the matrix A
2415 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2416 * @param incX The increment for the elements of vector x, must be larger than zero.
2419 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2423 * A*x = b or A**T*x = b
2425 * Details: http://www.netlib.org/lapack/explore-html/d0/d7c/stpsv_8f.html
2439 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2440 * @param incX The increment for the elements of vector x, must be larger than zero.
2443 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2447 * A*x = b or A**T*x = b
2449 * Details: http://www.netlib.org/lapack/explore-html/d9/d84/dtpsv_8f.html
2463 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2464 * @param incX The increment for the elements of vector x, must be larger than zero.
2467 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2471 * A*x = b or A**T*x = b or A**H*x = b
2473 * Details: http://www.netlib.org/lapack/explore-html/d8/d56/ctpsv_8f.html
2487 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2488 * @param incX The increment for the elements of vector x, must be larger than zero.
2491 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2495 * A*x = b or A**T*x = b or A**H*x = b
2497 * Details: http://www.netlib.org/lapack/explore-html/da/d57/ztpsv_8f.html
2511 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2512 * @param incX The increment for the elements of vector x, must be larger than zero.
2515 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2518 * SSYMV performs the matrix-vector operation
2519 * y := alpha*A*x + beta*y
2521 * Details: http://www.netlib.org/lapack/explore-html/d2/d94/ssymv_8f.html
2524 * @param alpha The scalar alpha.
2526 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2527 * @param incX The increment for the elements of vector x, must be larger than zero.
2532 void SSYMV(RsBlasUplo Uplo, float alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2536 * SSBMV performs the matrix-vector operation
2537 * y := alpha*A*x + beta*y
2539 * Details: http://www.netlib.org/lapack/explore-html/d3/da1/ssbmv_8f.html
2543 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2546 * b[i, j-i] = a[i, j]
2549 * @param K The number of off-diagonals of the matrix A
2550 * @param alpha The scalar alpha.
2552 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2553 * @param incX The increment for the elements of vector x, must be larger than zero.
2558 … void SSBMV(RsBlasUplo Uplo, int K, float alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2562 * SSPMV performs the matrix-vector operation
2563 * y := alpha*A*x + beta*y
2565 * Details: http://www.netlib.org/lapack/explore-html/d8/d68/sspmv_8f.html
2576 * @param alpha The scalar alpha.
2578 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2579 * @param incX The increment for the elements of vector x, must be larger than zero.
2584 void SSPMV(RsBlasUplo Uplo, float alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
2589 * A := alpha*x*y**T + A
2591 * Details: http://www.netlib.org/lapack/explore-html/db/d5c/sger_8f.html
2593 * @param alpha The scalar alpha.
2594 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2595 * @param incX The increment for the elements of vector x, must be larger than zero.
2600 …void SGER(float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Y, int incY, const…
2604 * A := alpha*x*x**T + A
2606 * Details: http://www.netlib.org/lapack/explore-html/d6/dac/ssyr_8f.html
2609 * @param alpha The scalar alpha.
2610 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2611 * @param incX The increment for the elements of vector x, must be larger than zero.
2614 …void SSYR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A…
2618 * A := alpha*x*x**T + A
2620 * Details: http://www.netlib.org/lapack/explore-html/d2/d9b/sspr_8f.html
2631 * @param alpha The scalar alpha.
2632 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2633 * @param incX The increment for the elements of vector x, must be larger than zero.
2636 …void SSPR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A…
2640 * A := alpha*x*y**T + alpha*y*x**T + A
2642 * Details: http://www.netlib.org/lapack/explore-html/db/d99/ssyr2_8f.html
2645 * @param alpha The scalar alpha.
2646 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2647 * @param incX The increment for the elements of vector x, must be larger than zero.
2652 void SSYR2(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX,
2657 * A := alpha*x*y**T + alpha*y*x**T + A
2659 * Details: http://www.netlib.org/lapack/explore-html/db/d3e/sspr2_8f.html
2670 * @param alpha The scalar alpha.
2671 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2672 * @param incX The increment for the elements of vector x, must be larger than zero.
2677 void SSPR2(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX,
2681 * DSYMV performs the matrix-vector operation
2682 * y := alpha*A*x + beta*y
2684 * Details: http://www.netlib.org/lapack/explore-html/d8/dbe/dsymv_8f.html
2687 * @param alpha The scalar alpha.
2689 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2690 * @param incX The increment for the elements of vector x, must be larger than zero.
2695 …void DSYMV(RsBlasUplo Uplo, double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int in…
2699 * DSBMV performs the matrix-vector operation
2700 * y := alpha*A*x + beta*y
2702 * Details: http://www.netlib.org/lapack/explore-html/d8/d1e/dsbmv_8f.html
2706 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2709 * b[i, j-i] = a[i, j]
2712 * @param K The number of off-diagonals of the matrix A
2713 * @param alpha The scalar alpha.
2715 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2716 * @param incX The increment for the elements of vector x, must be larger than zero.
2721 …void DSBMV(RsBlasUplo Uplo, int K, double alpha, const sp<Allocation>& A, const sp<Allocation>& X,…
2725 * DSPMV performs the matrix-vector operation
2726 * y := alpha*A*x + beta*y
2728 * Details: http://www.netlib.org/lapack/explore-html/d4/d85/dspmv_8f.html
2739 * @param alpha The scalar alpha.
2741 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2742 * @param incX The increment for the elements of vector x, must be larger than zero.
2747 …void DSPMV(RsBlasUplo Uplo, double alpha, const sp<Allocation>& Ap, const sp<Allocation>& X, int i…
2752 * A := alpha*x*y**T + A
2754 * Details: http://www.netlib.org/lapack/explore-html/dc/da8/dger_8f.html
2756 * @param alpha The scalar alpha.
2757 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2758 * @param incX The increment for the elements of vector x, must be larger than zero.
2763 …void DGER(double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Y, int incY, cons…
2767 * A := alpha*x*x**T + A
2769 * Details: http://www.netlib.org/lapack/explore-html/d3/d60/dsyr_8f.html
2772 * @param alpha The scalar alpha.
2773 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2774 * @param incX The increment for the elements of vector x, must be larger than zero.
2777 …void DSYR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& …
2781 * A := alpha*x*x**T + A
2783 * Details: http://www.netlib.org/lapack/explore-html/dd/dba/dspr_8f.html
2794 * @param alpha The scalar alpha.
2795 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2796 * @param incX The increment for the elements of vector x, must be larger than zero.
2799 …void DSPR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& …
2803 * A := alpha*x*y**T + alpha*y*x**T + A
2805 * Details: http://www.netlib.org/lapack/explore-html/de/d41/dsyr2_8f.html
2808 * @param alpha The scalar alpha.
2809 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2810 * @param incX The increment for the elements of vector x, must be larger than zero.
2815 void DSYR2(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX,
2820 * A := alpha*x*y**T + alpha*y*x**T + A
2822 * Details: http://www.netlib.org/lapack/explore-html/dd/d9e/dspr2_8f.html
2833 * @param alpha The scalar alpha.
2834 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2835 * @param incX The increment for the elements of vector x, must be larger than zero.
2840 void DSPR2(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX,
2844 * CHEMV performs the matrix-vector operation
2845 * y := alpha*A*x + beta*y
2847 * Details: http://www.netlib.org/lapack/explore-html/d7/d51/chemv_8f.html
2850 * @param alpha The scalar alpha.
2852 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2853 * @param incX The increment for the elements of vector x, must be larger than zero.
2858 void CHEMV(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2862 * CHBMV performs the matrix-vector operation
2863 * y := alpha*A*x + beta*y
2865 * Details: http://www.netlib.org/lapack/explore-html/db/dc2/chbmv_8f.html
2869 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
2872 * b[i, j-i] = a[i, j]
2875 * @param K The number of off-diagonals of the matrix A
2876 * @param alpha The scalar alpha.
2878 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2879 * @param incX The increment for the elements of vector x, must be larger than zero.
2884 … void CHBMV(RsBlasUplo Uplo, int K, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2888 * CHPMV performs the matrix-vector operation
2889 * y := alpha*A*x + beta*y
2891 * Details: http://www.netlib.org/lapack/explore-html/d2/d06/chpmv_8f.html
2902 * @param alpha The scalar alpha.
2904 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2905 * @param incX The increment for the elements of vector x, must be larger than zero.
2910 void CHPMV(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
2915 * A := alpha*x*y**T + A
2917 * Details: http://www.netlib.org/lapack/explore-html/db/d5f/cgeru_8f.html
2919 * @param alpha The scalar alpha.
2920 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2921 * @param incX The increment for the elements of vector x, must be larger than zero.
2926 void CGERU(Float2 alpha, const sp<Allocation>& X, int incX,
2931 * A := alpha*x*y**H + A
2933 * Details: http://www.netlib.org/lapack/explore-html/dd/d84/cgerc_8f.html
2935 * @param alpha The scalar alpha.
2936 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2937 * @param incX The increment for the elements of vector x, must be larger than zero.
2942 void CGERC(Float2 alpha, const sp<Allocation>& X, int incX,
2947 * A := alpha*x*x**H + A
2949 * Details: http://www.netlib.org/lapack/explore-html/d3/d6d/cher_8f.html
2952 * @param alpha The scalar alpha.
2953 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2954 * @param incX The increment for the elements of vector x, must be larger than zero.
2957 …void CHER(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A…
2961 * A := alpha*x*x**H + A
2963 * Details: http://www.netlib.org/lapack/explore-html/db/dcd/chpr_8f.html
2974 * @param alpha The scalar alpha.
2975 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2976 * @param incX The increment for the elements of vector x, must be larger than zero.
2979 …void CHPR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A…
2983 * A := alpha*x*y**H + alpha*y*x**H + A
2985 * Details: http://www.netlib.org/lapack/explore-html/db/d87/cher2_8f.html
2988 * @param alpha The scalar alpha.
2989 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2990 * @param incX The increment for the elements of vector x, must be larger than zero.
2995 void CHER2(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& X, int incX,
3000 * A := alpha*x*y**H + alpha*y*x**H + A
3002 * Details: http://www.netlib.org/lapack/explore-html/d6/d44/chpr2_8f.html
3013 * @param alpha The scalar alpha.
3014 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
3015 * @param incX The increment for the elements of vector x, must be larger than zero.
3020 void CHPR2(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& X, int incX,
3024 * ZHEMV performs the matrix-vector operation
3025 * y := alpha*A*x + beta*y
3027 * Details: http://www.netlib.org/lapack/explore-html/d0/ddd/zhemv_8f.html
3030 * @param alpha The scalar alpha.
3032 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3033 * @param incX The increment for the elements of vector x, must be larger than zero.
3038 void ZHEMV(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
3042 * ZHBMV performs the matrix-vector operation
3043 * y := alpha*A*x + beta*y
3045 * Details: http://www.netlib.org/lapack/explore-html/d3/d1a/zhbmv_8f.html
3049 … * example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
3052 * b[i, j-i] = a[i, j]
3055 * @param K The number of off-diagonals of the matrix A
3056 * @param alpha The scalar alpha.
3058 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3059 * @param incX The increment for the elements of vector x, must be larger than zero.
3064 …void ZHBMV(RsBlasUplo Uplo, int K, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
3068 * ZHPMV performs the matrix-vector operation
3069 * y := alpha*A*x + beta*y
3071 * Details: http://www.netlib.org/lapack/explore-html/d0/d60/zhpmv_8f.html
3082 * @param alpha The scalar alpha.
3084 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3085 * @param incX The increment for the elements of vector x, must be larger than zero.
3090 void ZHPMV(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
3095 * A := alpha*x*y**T + A
3097 * Details: http://www.netlib.org/lapack/explore-html/d7/d12/zgeru_8f.html
3099 * @param alpha The scalar alpha.
3100 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3101 * @param incX The increment for the elements of vector x, must be larger than zero.
3106 void ZGERU(Double2 alpha, const sp<Allocation>& X, int incX,
3111 * A := alpha*x*y**H + A
3113 * Details: http://www.netlib.org/lapack/explore-html/d3/dad/zgerc_8f.html
3115 * @param alpha The scalar alpha.
3116 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3117 * @param incX The increment for the elements of vector x, must be larger than zero.
3122 void ZGERC(Double2 alpha, const sp<Allocation>& X, int incX,
3127 * A := alpha*x*x**H + A
3129 * Details: http://www.netlib.org/lapack/explore-html/de/d0e/zher_8f.html
3132 * @param alpha The scalar alpha.
3133 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3134 * @param incX The increment for the elements of vector x, must be larger than zero.
3137 …void ZHER(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& …
3141 * A := alpha*x*x**H + A
3143 * Details: http://www.netlib.org/lapack/explore-html/de/de1/zhpr_8f.html
3154 * @param alpha The scalar alpha.
3155 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3156 * @param incX The increment for the elements of vector x, must be larger than zero.
3159 …void ZHPR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& …
3163 * A := alpha*x*y**H + alpha*y*x**H + A
3165 * Details: http://www.netlib.org/lapack/explore-html/da/d8a/zher2_8f.html
3168 * @param alpha The scalar alpha.
3169 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3170 * @param incX The increment for the elements of vector x, must be larger than zero.
3175 void ZHER2(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& X, int incX,
3180 * A := alpha*x*y**H + alpha*y*x**H + A
3182 * Details: http://www.netlib.org/lapack/explore-html/d5/d52/zhpr2_8f.html
3193 * @param alpha The scalar alpha.
3194 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3195 * @param incX The increment for the elements of vector x, must be larger than zero.
3200 void ZHPR2(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& X, int incX,
3204 * SGEMM performs one of the matrix-matrix operations
3205 * C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T
3207 * Details: http://www.netlib.org/lapack/explore-html/d4/de2/sgemm_8f.html
3211 * @param alpha The scalar alpha.
3217 void SGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, float alpha, const sp<Allocation>& A,
3222 * DGEMM performs one of the matrix-matrix operations
3223 * C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T
3225 * Details: http://www.netlib.org/lapack/explore-html/d7/d2b/dgemm_8f.html
3229 * @param alpha The scalar alpha.
3235 … void DGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, double alpha, const sp<Allocation>& A,
3239 * CGEMM performs one of the matrix-matrix operations
3240 …* C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) =…
3242 * Details: http://www.netlib.org/lapack/explore-html/d6/d5b/cgemm_8f.html
3246 * @param alpha The scalar alpha.
3252 … void CGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, Float2 alpha, const sp<Allocation>& A,
3256 * ZGEMM performs one of the matrix-matrix operations
3257 …* C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) =…
3259 * Details: http://www.netlib.org/lapack/explore-html/d7/d76/zgemm_8f.html
3263 * @param alpha The scalar alpha.
3269 … void ZGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, Double2 alpha, const sp<Allocation>& A,
3273 * SSYMM performs one of the matrix-matrix operations
3274 * C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
3276 * Details: http://www.netlib.org/lapack/explore-html/d7/d42/ssymm_8f.html
3280 * @param alpha The scalar alpha.
3286 void SSYMM(RsBlasSide Side, RsBlasUplo Uplo, float alpha, const sp<Allocation>& A,
3290 * DSYMM performs one of the matrix-matrix operations
3291 * C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
3293 * Details: http://www.netlib.org/lapack/explore-html/d8/db0/dsymm_8f.html
3297 * @param alpha The scalar alpha.
3303 void DSYMM(RsBlasSide Side, RsBlasUplo Uplo, double alpha, const sp<Allocation>& A,
3307 * CSYMM performs one of the matrix-matrix operations
3308 * C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
3310 * Details: http://www.netlib.org/lapack/explore-html/db/d59/csymm_8f.html
3314 * @param alpha The scalar alpha.
3320 void CSYMM(RsBlasSide Side, RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A,
3324 * ZSYMM performs one of the matrix-matrix operations
3325 * C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
3327 * Details: http://www.netlib.org/lapack/explore-html/df/d51/zsymm_8f.html
3331 * @param alpha The scalar alpha.
3337 void ZSYMM(RsBlasSide Side, RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A,
3342 * C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
3344 * Details: http://www.netlib.org/lapack/explore-html/d0/d40/ssyrk_8f.html
3348 * @param alpha The scalar alpha.
3353 void SSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, float alpha,
3358 * C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
3360 * Details: http://www.netlib.org/lapack/explore-html/dc/d05/dsyrk_8f.html
3364 * @param alpha The scalar alpha.
3369 void DSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, double alpha,
3374 * C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
3376 * Details: http://www.netlib.org/lapack/explore-html/d3/d6a/csyrk_8f.html
3380 * @param alpha The scalar alpha.
3385 void CSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, Float2 alpha,
3390 * C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
3392 * Details: http://www.netlib.org/lapack/explore-html/de/d54/zsyrk_8f.html
3396 * @param alpha The scalar alpha.
3401 void ZSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, Double2 alpha,
3406 * C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
3408 * Details: http://www.netlib.org/lapack/explore-html/df/d3d/ssyr2k_8f.html
3412 * @param alpha The scalar alpha.
3418 void SSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, float alpha,
3423 * C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
3425 * Details: http://www.netlib.org/lapack/explore-html/d1/dec/dsyr2k_8f.html
3429 * @param alpha The scalar alpha.
3435 void DSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, double alpha,
3440 * C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
3442 * Details: http://www.netlib.org/lapack/explore-html/de/d7e/csyr2k_8f.html
3446 * @param alpha The scalar alpha.
3452 void CSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Float2 alpha,
3457 * C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
3459 * Details: http://www.netlib.org/lapack/explore-html/df/d20/zsyr2k_8f.html
3463 * @param alpha The scalar alpha.
3469 void ZSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Double2 alpha,
3473 * STRMM performs one of the matrix-matrix operations
3474 * B := alpha*op(A)*B or B := alpha*B*op(A)
3477 * Details: http://www.netlib.org/lapack/explore-html/df/d01/strmm_8f.html
3483 * @param alpha The scalar alpha.
3488 RsBlasDiag Diag, float alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3491 * DTRMM performs one of the matrix-matrix operations
3492 * B := alpha*op(A)*B or B := alpha*B*op(A)
3495 * Details: http://www.netlib.org/lapack/explore-html/dd/d19/dtrmm_8f.html
3501 * @param alpha The scalar alpha.
3506 double alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3509 * CTRMM performs one of the matrix-matrix operations
3510 * B := alpha*op(A)*B or B := alpha*B*op(A)
3513 * Details: http://www.netlib.org/lapack/explore-html/d4/d9b/ctrmm_8f.html
3519 * @param alpha The scalar alpha.
3524 Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3527 * ZTRMM performs one of the matrix-matrix operations
3528 * B := alpha*op(A)*B or B := alpha*B*op(A)
3531 * Details: http://www.netlib.org/lapack/explore-html/d8/de1/ztrmm_8f.html
3537 * @param alpha The scalar alpha.
3542 Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3546 * op(A)*X := alpha*B or X*op(A) := alpha*B
3549 * Details: http://www.netlib.org/lapack/explore-html/d2/d8b/strsm_8f.html
3555 * @param alpha The scalar alpha.
3560 float alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3564 * op(A)*X := alpha*B or X*op(A) := alpha*B
3567 * Details: http://www.netlib.org/lapack/explore-html/de/da7/dtrsm_8f.html
3573 * @param alpha The scalar alpha.
3578 double alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3582 * op(A)*X := alpha*B or X*op(A) := alpha*B
3585 * Details: http://www.netlib.org/lapack/explore-html/de/d30/ctrsm_8f.html
3591 * @param alpha The scalar alpha.
3596 Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3600 * op(A)*X := alpha*B or X*op(A) := alpha*B
3603 * Details: http://www.netlib.org/lapack/explore-html/d1/d39/ztrsm_8f.html
3609 * @param alpha The scalar alpha.
3614 Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3617 * CHEMM performs one of the matrix-matrix operations
3618 * C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
3620 * Details: http://www.netlib.org/lapack/explore-html/d3/d66/chemm_8f.html
3624 * @param alpha The scalar alpha.
3630 void CHEMM(RsBlasSide Side, RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A,
3634 * ZHEMM performs one of the matrix-matrix operations
3635 * C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
3637 * Details: http://www.netlib.org/lapack/explore-html/d6/d3e/zhemm_8f.html
3641 * @param alpha The scalar alpha.
3647 void ZHEMM(RsBlasSide Side, RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A,
3652 * C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C
3654 * Details: http://www.netlib.org/lapack/explore-html/d8/d52/cherk_8f.html
3658 * @param alpha The scalar alpha.
3663 void CHERK(RsBlasUplo Uplo, RsBlasTranspose Trans, float alpha, const sp<Allocation>& A,
3668 * C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C
3670 * Details: http://www.netlib.org/lapack/explore-html/d1/db1/zherk_8f.html
3674 * @param alpha The scalar alpha.
3679 void ZHERK(RsBlasUplo Uplo, RsBlasTranspose Trans, double alpha, const sp<Allocation>& A,
3684 …* C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**…
3686 * Details: http://www.netlib.org/lapack/explore-html/d1/d82/cher2k_8f.html
3690 * @param alpha The scalar alpha.
3696 void CHER2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Float2 alpha, const sp<Allocation>& A,
3701 …* C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**…
3703 * Details: http://www.netlib.org/lapack/explore-html/d7/dfa/zher2k_8f.html
3707 * @param alpha The scalar alpha.
3713 void ZHER2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Double2 alpha, const sp<Allocation>& A,
3717 * 8-bit GEMM-like operation for neural networks: C = A * Transpose(B)
3718 * Calculations are done in 1.10.21 fixed-point format for the final output,
3720 * values are gated to 0 to 255 to fit in a byte, but the 10-bit format
3724 …* @param a_offset The offset for all values in matrix A, e.g A[i,j] = A[i,j] - a_offset. Value sho…
3726 …* @param b_offset The offset for all values in matrix B, e.g B[i,j] = B[i,j] - b_offset. Value sho…
3768 * Sets dst = src + dst * (1.0 - src.a)
3774 * Sets dst = dst + src * (1.0 - dst.a)
3792 * Sets dst = src * (1.0 - dst.a)
3798 * Sets dst = dst * (1.0 - src.a)
3804 * Sets dst.rgb = src.rgb * dst.a + (1.0 - src.a) * dst.rgb
3810 * Sets dst.rgb = dst.rgb * src.a + (1.0 - dst.a) * src.rgb
3834 * Sets dst = max(dst - src, 0.0)
3906 * image. The alpha channel will be copied.
3919 * Set a color matrix to convert from RGB to luminance. The alpha
4035 * @param[in] a Alpha coefficient
4065 * Intrinsic for applying a per-channel lookup table. Each channel of
4119 * Sets entries in LUT for the alpha channel.
4146 * Allocation is rescaled if necessary using bi-cubic
4164 * as a YUV element Allocation. The output is RGBA; the alpha channel
4222 * Creates a non-standard Sampler.