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

* * Compute the Cholesky factorization of a symmetric positive definite * N-by-N matrix A. * * Arguments: * A On entry, the symmetric matrix

* * Compute QR factorization of a M-by-N matrix A using compact WY transformation: A = Q * R, * where Q = I - Y*T*Y.T, T is block reflector and Y ho

Compute in-place inverse A[i,j] = 1.0/A[i,j]. If indexes is empty calculates for all elements

IsPrime returns true if n is prime. Typical run time is about 100 ns. TODO rename to IsPrimeUint32

* * Compute * C = C*diag(D) flags & RIGHT == true * C = diag(D)*C flags & LEFT == true * * Arguments * C M-by-N matrix if f

Create a new OSGB36 coordinate from literals. The parameter prec plays an important role in how the literals are interpreted: OSGB36Auto - for easting

ProbablyPrimeBigInt returns true if n is prime or n is a pseudoprime to base a. It implements the Miller-Rabin primality test for one specific value o

Reset cached score

* * Compute * X = B*diag(D).-1 flags & RIGHT == true * X = diag(D).-1*C flags & LEFT == true * * Arguments: * B M-by-N matr

* Get a new matrix [A; B], with A above B. */

Calculate sum of packed dimensions over set of keys.

* From: http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan Counting bits set, Brian Kernighan's way unsigned int v; // count

* Repartition 1 by 2 blocks to 1 by 3 blocks. pRIGHT: AL | AR -- A0 A1 | A2 pLEFT: AL | AR <-- A0 | A1 A2 */

The ordering is reversed because push and pop are faster. [MC: fragment from .c source below:] Return true means that [...] e1 is processed by the alg

* Repartition 1 by 2 blocks to 1 by 3 blocks. pRIGHT: AL | AR --> A0 | A1 A2 pLEFT: AL | AR --> A0 A1 | A2 Parameter As is left or right bl

Append matrices to matrix set.

Matrix-Vector operators blas GEMV; blocked version Y = alpha*A*X + beta*Y; Y is M*1, X is N*1 and A is M*N

* * Compute an LDLT factorization of a symmetric N-by-N matrix with partial pivoting. * * Arguments: * A On entry, the N-by-N matrix to be

Dot-product of two Vectors.

FactorInt returns prime factorization of n > 1 or nil otherwise. Resulting factors are ordered by Prime. Typical run time is few µs.

Create a column-major matrix from a array of arrays. Parameter order indicates if data is array of rows (RowOrder) or array of columns (ColumnOrder).

Create a column-major matrix from a flat array of elements. Assumes values are in column-major order.

Ftoa converts a float to a string with no trailing zeros.

IsPrimeUint64 returns true if n is prime. Typical run time is few tens of µs. SPRP bases: http://miller-rabin.appspot.com

Matrix-vector triangular update A = A + alpha*X*Y.T A is N*N matrix, X is row or column vector of length N Y is row or column vector of legth N. flags

ProbScores works the same as LogScores, but delivers actual probabilities as discussed above. Note that float64 underflow is possible if the word list

ProbablyPrimeBigInt_32 returns true if n is prime or n is a pseudoprime to base a. It implements the Miller-Rabin primality test for one specific valu

* quantiles.go * * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough * Copyright (C) 2012, 2013 G.vd.Schoot * * This pro

Serialize this classifier to GOB and write to Writer

backup steps back one rune. Can only be called once per call of next.

=========================== [ Helper Functions ] =========================== Check if two vectors have the same dimension.

* Returns sqrt(x' * J * x) where J = [1, 0; 0, -I], for a vector x in a second order cone. */

this function left aligns children terms ( ie move nils to end of terms[] ) and returns the number of children

Create a column-major matrix from a flat array of elements. Elements slice is not copied to internal elements but assigned, so underlying array holdin

Create a column-major matrix from a flat array of elements. Elements slice is not copied to internal elements but assigned, so underlying array holdin

* * like LAPACK/dlafrt.f * * Build block reflector T from HH reflector stored in TriLU(A) and coefficients * in tau. * * Q = I - Y*T*Y.T; Househ

compute: Q.T*C = (I -Y*T*Y.T).T*C == C - Y*(C.T*Y*T).T or Q*C = (I -Y*T*Y.T)*C == C - Y*(C.T*Y*T.T).T where C = /C1\ Y = /Y1\ \C2/ \Y

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

* Returns an array of slices referencing the matrix data. Changes to the slices effect changes to the matrix. */

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

BoundingBox finds minimum and maximum coordinates of points in a contour.

Checks if a point is inside a contour using the "point in polygon" raycast method. This works for all polygons, whether they are clockwise or counter

* * Compute QR factorization of a M-by-N matrix A: A = Q * R. * * Arguments: * A On entry, the M-by-N matrix A. On exit, the elements on and ab

Returns a tuple (f, Df) where f is of size (mnl, 1) containing f(x) Df is matrix of size (mnl, n) containing the derivatives of f at x: Df[k,:] is the

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

Mod sets mod to n % Mexp and returns mod. It panics for exp == 0 || exp >= math.MaxInt32 || n < 0.

ModPowBigInt computes (b^e)%m. Returns nil for e < 0. It panics for m == 0 || b == e == 0.

* * Multiply and replace C with Q*C or Q.T*C where Q is a real orthogonal matrix * defined as the product of k elementary reflectors. * * Q = H

* * Multiply and replace C with Q*C or Q.T*C where Q is a real orthogonal matrix * defined as the product of k elementary reflectors and block refle

HELMERT Transformation - http://en.wikipedia.org/wiki/Helmert_transformation Returns a new ellipsoid by the given major axis a and major axis b in met

Create a Vector from a slice. Its dimension is equal to len(slice).

ParseBigBytes parses a string representation of bytes into the number of bytes it represents. See also: BigBytes, BigIBytes. ParseBigBytes("42MB") -

ParseBytes parses a string representation of bytes into the number of bytes it represents. See Also: Bytes, IBytes. ParseBytes("42MB") -> 42000000,

PopCountUint32 returns population count of n (number of bits set in n).

PopCountUint64 returns population count of n (number of bits set in n).