MCPcopy Create free account

hub / github.com/andeya/algorithm / functions

Functions3,549 in github.com/andeya/algorithm

⨍ Functions 3,549◇ Types & classes 331
↓ 25 callersFunctionZeros
(rows, cols int)
go.matrix/dense.go:247
↓ 25 callersFunctionbenchmarkPowerizeBigInt
(b *testing.B, base uint32, exp int)
mathutil/all_test.go:2628
↓ 25 callersFunctionbenchmarkPowerizeUint32BigInt
(b *testing.B, base uint32, exp int)
mathutil/all_test.go:2458
↓ 25 callersFunctionscale
* Applies Nesterov-Todd scaling or its inverse. Computes x := W*x (trans is false 'N', inverse = false 'N') x := W^T*x
cvx/misc.go:85
↓ 24 callersFunctionComma
Comma produces a string form of the given number in base 10 with commas after every three orders of magnitude. e.g. Comma(834142) -> 834,142
go-humanize/comma.go:14
↓ 24 callersMethodEqualsCoord
(q Coord)
geom/coord.go:62
↓ 24 callersMethodGet
(i, j int)
go.matrix/sparse.go:22
↓ 24 callersMethodMax
Find maximum dimension in sets.
cvx/sets/sets.go:187
↓ 24 callersMethodSetIndexes
Set element values in column-major ordering. Negative indexes are relative to the last element of the matrix. If len(indexes) is zero sets all element
matrix/dense.go:486
↓ 24 callersFunctionfail
(t *testing.T, isok bool)
matops/calgo/calgo_test.go:95
↓ 24 callersFunctiongsl_test
(status bool, test_description string, a ...interface{})
stat/main_test.go:30
↓ 24 callersFunctiontrmmTest
(t *testing.T, A *matrix.FloatMatrix, flags Flags, nb int)
matops/calgo/ttrm_test.go:82
↓ 23 callersMethodBounds
()
geom/geom.go:8
↓ 23 callersFunctionProduct
* Finds the Product of two matrices. */
go.matrix/arithmetic.go:42
↓ 23 callersFunctionbigComma
(i int64)
go-humanize/comma_test.go:84
↓ 23 callersFunctionr64
()
mathutil/all_test.go:74
↓ 23 callersMethodt
()
cvx/cp.go:99
↓ 22 callersMethodGetRowColIndex
* Turn an element index into a row and column number. */
go.matrix/sparse.go:65
↓ 22 callersFunctionNewPowI
(e Expr, i int)
go-symexpr/types.go:237
↓ 22 callersFunctionSwap
Swap X and Y.
matops/mvec.go:452
↓ 21 callersMethodComplex
()
matrix/matrix.go:35
↓ 21 callersFunctionEquals
* Tests the element-wise equality of the two matrices. */
go.matrix/arithmetic.go:175
↓ 21 callersMethodIntn
(n int)
dice/rng.go:30
↓ 21 callersFunctionNewNeg
(e Expr)
go-symexpr/types.go:90
↓ 21 callersFunctionrect
(x, y, w, h float64)
polyclip-go/geom_test.go:46
↓ 21 callersFunctionsymm
Converts lower triangular matrix to symmetric. Fills in the upper triangular part of the symmetric matrix stored in x[offset : offset+n*n] using 'L' s
cvx/misc.go:942
↓ 20 callersMethodClone
()
go-symexpr/types.go:329
↓ 20 callersMethodHasVarI
(i int)
go-symexpr/expr.go:75
↓ 20 callersMethodHeight
()
go-symexpr/expr.go:61
↓ 20 callersFunctionInvScale
Inverse scaling of vector. X = X / alpha.
matops/mvec.go:418
↓ 20 callersFunctionMultTrm
Triangular matrix multiply. (blas.TRMM) B = alpha*A*B if flags&LEFT B = alpha*A.T*B if flags&(LEFT|TRANSA) B = alpha*B*A if flags&RIGHT B = alp
matops/mmult.go:338
↓ 20 callersFunctionNormP
* * Compute matrix and vector norms. * * Arguments * X A real valued matrix or vector * * norm Norm to compute * NORM_ONE, NORM_TW
matops/norm.go:58
↓ 20 callersMethodString
print.go prints the AST
go-symexpr/expr.go:107
↓ 20 callersMethodSumSquared
Calculate sum of squared dimensions over set of keys.
cvx/sets/sets.go:213
↓ 20 callersFunctionr32
============================================================================
mathutil/all_test.go:50
↓ 19 callersFunctionBytes
Bytes produces a human readable representation of an SI size. See also: ParseBytes. Bytes(82854982) -> 83MB
go-humanize/bytes.go:88
↓ 19 callersMethodLen
()
ga/genome.go:31
↓ 19 callersFunctionNewDiv
(n, d Expr)
go-symexpr/types.go:299
↓ 19 callersFunctionNewPowF
(b Expr, f float64)
go-symexpr/types.go:254
↓ 19 callersMethodPlus
(MatrixRO)
go.matrix/matrix.go:39
↓ 19 callersFunctioncheck_level1_func
(ind *linalg.IndexOpts, fn funcNum, X, Y matrix.Matrix)
linalg/blas/indexcheck.go:84
↓ 19 callersFunctioncmpf64
(f1, f2 float64)
units/units_test.go:12
↓ 19 callersFunctionisVector
(X *matrix.FloatMatrix)
matops/mmult.go:125
↓ 19 callersFunctionverify
(t *T, cond bool, format string, args ...interface{})
polyclip-go/geom_test.go:29
↓ 18 callersFunctionApproxEquals
* Tests to see if the difference between two matrices, element-wise, exceeds ε. */
go.matrix/arithmetic.go:193
↓ 18 callersMethodJavascript
(dnames, snames []string, cvals []float64)
go-symexpr/expr.go:124
↓ 18 callersMethodLatex
WriteString( buf *bytes.Buffer ) Similar to PrettyPrint, but in latex format
go-symexpr/expr.go:123
↓ 18 callersFunctionNew
============================= [ Constructors ] ============================= Create a Vector with dimension n, with all values initialized to 0.
vector/vector.go:32
↓ 18 callersMethodPrettyPrint
Pretty print acts like String, but replaces the internal indexed formatting with user specified strings and values
go-symexpr/expr.go:119
↓ 18 callersMethodSeed
Seed uses the provided seed value to initialize the generator to a deterministic state. A zero seed produces a "canonical" generator with worse random
mathutil/rnd.go:115
↓ 18 callersMethodStackSerial
([]int)
go-symexpr/expr.go:115
↓ 18 callersFunctionabs
(val int)
linalg/blas/indexcheck.go:57
↓ 18 callersFunctionassertTrue
assertTrue() calls testing.T.Error() with the given message if the condition is false.
evaler/stack/stack_test.go:78
↓ 18 callersFunctionswapRows
(A *matrix.FloatMatrix, src, dst int)
matops/pivot.go:24
↓ 17 callersMethodError
()
cartconvert/cartconvert/cartconvert.go:31
↓ 17 callersFunctionFloatZeros
Create new zero filled matrix.
matrix/dense.go:235
↓ 17 callersMethodHasConstI
DFS for a indexed valued Constant
go-symexpr/expr.go:81
↓ 17 callersMethodSetExpr
DFS replacement of a node and it's subtree replaced is used to discontinue the DFS after replacement replace_me gets triggered when pos == 0 and infor
go-symexpr/expr.go:102
↓ 17 callersFunctionbibyte
(in uint64)
go-humanize/bigbytes_test.go:78
↓ 16 callersMethodAmIEqual
(rhs Expr)
go-symexpr/expr.go:68
↓ 16 callersMethodConvertToConstantFs
convert.go Converts indexed Constant nodes to ConstantF nodes using the input slice as the values for replacement
go-symexpr/expr.go:89
↓ 16 callersMethodConvertToConstants
DFS converting float valued constants to indexed constants the input should be an empty slice the output is an appended slice the size = |ConstantF| i
go-symexpr/expr.go:93
↓ 16 callersMethodDerivVar
deriv.go Calculate the derivative w.r.t. Var_i
go-symexpr/expr.go:140
↓ 16 callersMethodFloat64
()
fixed/fixed.go:148
↓ 16 callersMethodGetExpr
IndexConstants( ci int ) int getset.go DFS retrieval of a node by index
go-symexpr/expr.go:98
↓ 16 callersFunctionIBytes
IBytes produces a human readable representation of an IEC size. See also: ParseBytes. IBytes(82854982) -> 79MiB
go-humanize/bytes.go:98
↓ 16 callersFunctionMVMult
Compute Y = alpha*A*X + beta*Y Y = alpha*A.T*X + beta*Y ; flags = TRANSA A is M*N or N*M generic matrix, X is row or column vector of length N Y is
matops/mvec.go:27
↓ 16 callersFunctionNew
New returns Mn == 2^n-1 for n <= math.MaxInt32 or nil otherwise.
mathutil/mersenne/mersenne.go:106
↓ 16 callersFunctionNormalsSparse
* Creates a matrix and puts a standard normal in n random elements, with replacement. */
go.matrix/sparse.go:247
↓ 16 callersMethodPush
(x interface{})
evaler/stack/stack.go:32
↓ 16 callersMethodSerial
creates an integer representation of the AST in ~prefix notation The input is an empty slice, output is the representation. The output is generally th
go-symexpr/expr.go:114
↓ 16 callersMethodSetValue
Set value of singleton matrix.
matrix/dense.go:480
↓ 16 callersMethodSub
(y Fixed)
fixed/fixed.go:50
↓ 16 callersFunctionbbyte
(in uint64)
go-humanize/bigbytes_test.go:74
↓ 16 callersMethodcalcExprStatsR
(depth int, pos *int)
go-symexpr/expr.go:64
↓ 16 callersFunctioncontPivot3x1to2x1
* * Continue with 2 by 1 block from 3 by 1 block. * * pT p0 pT p0 * pBOTTOM: -- <-- p1 ; pTOP: -- <-- -- *
matops/partition.go:407
↓ 16 callersFunctioncontinue3x1to2x1
* Continue with 2 by 1 block from 3 by 1 block. AT A0 AT A0 pBOTTOM: -- <-- A1 ; pTOP: -- <-- --
matops/partition.go:89
↓ 16 callersFunctionpartition2x1
* Partition p to 2 by 1 blocks. AT A --> -- AB Parameter nb is initial block size for AT (pTOP) or AB (pBOTTOM). */
matops/partition.go:37
↓ 16 callersFunctionpartitionPivot2x1
* * Partition p to 2 by 1 blocks. * * pT * p --> -- * pB * * Parameter nb is initial block size for pT (pTOP) or pB (pBOTTOM).
matops/partition.go:349
↓ 16 callersFunctionrepartPivot2x1to3x1
* * Repartition 2 by 1 block to 3 by 1 block. * * pT p0 pT p0 * pBOTTOM: -- --> -- ; pTOP: -- --> p1 *
matops/partition.go:378
↓ 16 callersFunctionrepartition2x1to3x1
* Repartition 2 by 1 block to 3 by 1 block. AT A0 AT A0 pBOTTOM: -- --> -- ; pTOP: -- --> A1 AB
matops/partition.go:60
↓ 15 callersMethodCopy
()
go.matrix/dense.go:152
↓ 15 callersMethodDerivConst
Calculate the derivative w.r.t. Constant_i
go-symexpr/expr.go:142
↓ 15 callersMethodDiag
Make B diagonal of matrix A as submatrix vector.
matrix/dense.go:315
↓ 15 callersMethodString
Convert to string for printing
cvx/interfaces.go:183
↓ 15 callersFunctionZerosSparse
(rows int, cols int)
go.matrix/sparse.go:234
↓ 15 callersFunctioncolcpy
matops/calgo/colcpy.h:14
↓ 15 callersMethodemit
emit passes an item back to the client.
go-symexpr/lexer.go:193
↓ 15 callersFunctionsdot
Inner product of two vectors in S.
cvx/misc.go:917
↓ 14 callersFunctionIAMax
index of max |x|
matops/mvec.go:401
↓ 14 callersFunctionMultSym
Symmetric matrix multiply. (blas.SYMM) C = beta*C + alpha*A*B (default) C = beta*C + alpha*A.T*B flags&TRANSA C = beta*C + alpha*A*B.T flags&T
matops/mmult.go:266
↓ 14 callersMethodScore
Calculate score
ga/genome.go:18
↓ 14 callersMethodSet
Set the contents of matrix set.
cvx/sets/sets.go:62
↓ 14 callersMethodTranspose
()
go.matrix/pivot_basic.go:33
↓ 14 callersFunctioncheck_level3_func
(ind *linalg.IndexOpts, fn funcNum, A, B, C matrix.Matrix, pars *linalg.Parameters)
linalg/blas/indexcheck.go:414
↓ 14 callersFunctiondbg
(format string, args ...interface{})
geom/debug.go:11
↓ 14 callersMethodsegment
(index int)
polyclip-go/geom.go:106
↓ 13 callersMethodError
()
matrix/error.go:31
↓ 13 callersFunctionNewClassifier
NewClassifier returns a new classifier. The classes the provided should be at least 2 in number and unique, or this method will panic.
bayesian/bayesian.go:142
↓ 13 callersMethodSetIndexesFromArray
Set values of indexed elements.
matrix/dense.go:510
← previousnext →101–200 of 3,549, ranked by callers