* Copy B into A, with B's 0, 0 aligning with A's i, j */

Compute matrix product C = A * B where A is m*p and B is p*n. Returns a new m*n matrix.

* Get a copy of this matrix with 0s below the diagonal. */

func _DBG(f func()) { f() }

Second version; assumes C is correct destination block i.e C->md points to C[R, E]; and that A->md is start of A panel and B->md is start of B panel.

Update Y with 1 column of A

accept consumes the next rune if it's from the valid set.

acceptRun consumes a run of runes from the valid set.

next returns the next rune in the input.

serialize gets called by the respective handler methods to perform the serialization in the requested output representation

The product x := (y o x). If diag is 'D', the 's' part of y is diagonal and only the diagonal is stored.

AddUint128_64 returns the uint128 sum of uint64 a and b.

Make a copy C of A and apply function fn element wise to C. For indexes is not empty then C[indexes[i]] = fn(C[indexes[i]]). Returns a new matrix.

Compute A = fn(A, x) by applying function fn element wise to A. If indexes array is non-empty function is applied to elements of A indexed by the cont

* Get a new matrix [A B]. */

BigBytes produces a human readable representation of an SI size. See also: ParseBigBytes. BigBytes(82854982) -> 83MB

BigIBytes produces a human readable representation of an IEC size. See also: ParseBigBytes. BigIBytes(82854982) -> 79MiB

BitLenUintptr returns the bit width of the non zero part of n.

Solves a pair of primal and dual cone programs minimize c'*x subject to G*x + s = h A*x = b s >= 0 maximize -h'*z - b'*y subject to G'*z + A

Construct computes a 2D polygon, which is a result of performing specified Boolean operation on the provided pair of polygons (p <Op> clipping). It us

Compute the sum Y = \alpha X + Y for the vectors X and Y

* * Compute an LU factorization of a general M-by-N matrix using * partial pivoting with row interchanges. * * Arguments: * A On entry, th

* * Compute an LU factorization of a general M-by-N matrix without pivoting. * * Arguments: * A On entry, the M-by-N matrix to be factored. On

Dedupe returns n, the number of distinct elements in data. The resulting elements are sorted in elements [0, n) or data[:n] for a slice.

The determinant of this matrix.

Rescale the vector X by the multiplicative factor alpha

* Create an identity matrix with span rows and span columns. */

F(x, z) with z a positive matrix of size (mnl, 1). Return a tuple (f, Df, H), where f, Df as above. H is matrix of size (n, n).

HasFactorBigInt returns true if d | Mn, d > 0. Typical run time for a 128 bit factor and a 32 bit exponent is < 75 µs.

ISqrt returns floor(sqrt(n)). Typical run time is few hundreds of ns.

Create an index set. Three argument call is (start, end, step) where start < end and step > 0. It produces set of indexes from start to end-1 with ste

IsPrimeUint16 returns true if n is prime. Typical run time is few ns.

* Overwrites A with [L\U] and returns P, st PLU=A. L is considered to have 1s in the diagonal. */

Learned returns the number of documents ever learned in the lifetime of this classifier.

Length returns distance from p to point (0, 0).

Max finds the first largest member and the members position within the data

Given a set a points, return the mean vector. points.Rows() = dimensions. points.Cols() = number of points.

Min finds the first smallest member and the members position within the data

Minmax finds the first smallest and largest members and the members positions within the data

ModPow returns b^Me % Mm. Run time grows quickly with 'e' and/or 'm' when b != 2 (then ModPow2 is used).

ModPow2 returns x such that 2^Me % Mm == 2^x. It panics for m < 2. Typical run time is < 1 µs. Use instead of ModPow(2, e, m) wherever possible.

ModPowUint32 computes (b^e)%m. It panics for m == 0 || b == e == 0.

NextPrimeUint16 returns first prime > n and true if successful or an undefined value and false if there is no next prime in the uint16 limits. Typical

Pos reports the current position within the inner cycle.

Pos reports the current position within the inner cycle.

PowerizeBigInt returns (e, p) such that e is the smallest number for which p == b^e is greater or equal n. For n < 0 or b < 2 (0, nil) is returned. N

PrimorialProductsUint32 returns a slice of numbers in [lo, hi] which are a product of max 'max' primorials. The slice is not sorted. See also: http:/

Remove set.

SafeProbScores works the same as ProbScores, but is able to detect underflow in those cases where underflow results in the reverse classification. If

Compute the sum Y = \alpha X + Y for the vectors X and Y

Scaling with scalar: X = alpha * X

Set the element in the i'th row and j'th column to val.

SqrtUint64 returns floor(sqrt(n)). Typical run time is about 0.5 µs.

Rescale the vector X by the multiplicative factor alpha

Method to perform the Helmert transformation on a generic 3D datum and return a new datum. Instances of helmert transformations might be created by ca

Make A tridiagonal, lower, non-unit matrix by clearing the strictly upper part of the matrix.

WordCount returns the number of words counted for each class in the lifetime of the classifier.

This will do efectively AXPY C[:,i] = w * A[:,k] + C[:,i] where w = alpha * B[k,i]

update 1 column of A matrix (a0) with vector X scaled with elements y0

update 2 columns of A matrix (a0, a1) with vector X scaled with elements y0, y1

(1.0 + sqrt(17.0))/8.0 * * Apply diagonal pivot (row and column swapped) to symmetric matrix blocks. * * LOWER triangular; moving from top-left to