Options
All
  • Public
  • Public/Protected
  • All
Menu

UNITS 1.6.3

Index

Classes

Interfaces

Variables

Functions

Object literals

Variables

Const BASE

BASE: 10000000 = 10000000

Const BASIS_LABELS_G3_GEOMETRIC

BASIS_LABELS_G3_GEOMETRIC: string[][] = [[SCALAR_POS_SYMBOL, SCALAR_POS_SYMBOL],[E1_NEG_SYMBOL, E1_POS_SYMBOL],[E2_NEG_SYMBOL, E2_POS_SYMBOL],[E3_NEG_SYMBOL, E3_POS_SYMBOL],[E12_NEG_SYMBOL, E12_POS_SYMBOL],[E23_NEG_SYMBOL, E23_POS_SYMBOL],[E31_NEG_SYMBOL, E31_POS_SYMBOL],[PSEUDO_NEG_SYMBOL, PSEUDO_POS_SYMBOL]]

Const BASIS_LABELS_G3_HAMILTON

BASIS_LABELS_G3_HAMILTON: string[][] = [[SCALAR_SYMBOL],[E1_SYMBOL],[E2_SYMBOL],[E3_SYMBOL],[E12_SYMBOL],[E23_SYMBOL],[E31_SYMBOL],[PSEUDO_SYMBOL]]

Const BASIS_LABELS_G3_STANDARD

BASIS_LABELS_G3_STANDARD: string[][] = [[SCALAR_SYMBOL],[E1_SYMBOL],[E2_SYMBOL],[E3_SYMBOL],[E12_SYMBOL],[E23_SYMBOL],[E31_SYMBOL],[PSEUDO_SYMBOL]]

Const BASIS_LABELS_G3_STANDARD_HTML

BASIS_LABELS_G3_STANDARD_HTML: string[][] = [[SCALAR_SYMBOL],[E1_SYMBOL],[E2_SYMBOL],[E3_SYMBOL],[E12_SYMBOL],[E23_SYMBOL],[E31_SYMBOL],[PSEUDO_SYMBOL]]

Const COORD_PSEUDO

COORD_PSEUDO: 7 = 7

Const COORD_SCALAR

COORD_SCALAR: 0 = 0

Const COORD_W

COORD_W: 0 = 0

Const COORD_X

COORD_X: 1 = 1

Const COORD_XY

COORD_XY: 4 = 4

Const COORD_XYZ

COORD_XYZ: 7 = 7

Const COORD_Y

COORD_Y: 2 = 2

Const COORD_YZ

COORD_YZ: 5 = 5

Const COORD_Z

COORD_Z: 3 = 3

Const COORD_ZX

COORD_ZX: 6 = 6

Const E12_NEG_SYMBOL

E12_NEG_SYMBOL: "↻" = "↻"

Const E12_POS_SYMBOL

E12_POS_SYMBOL: "↺" = "↺"

Const E12_SYMBOL

E12_SYMBOL: "e12" = "e12"

Const E1_NEG_SYMBOL

E1_NEG_SYMBOL: "←" = "←"

Const E1_POS_SYMBOL

E1_POS_SYMBOL: "→" = "→"

Const E1_SYMBOL

E1_SYMBOL: "e1" = "e1"

Const E23_NEG_SYMBOL

E23_NEG_SYMBOL: "⬘" = "⬘"

Const E23_POS_SYMBOL

E23_POS_SYMBOL: "⬙" = "⬙"

Const E23_SYMBOL

E23_SYMBOL: "e23" = "e23"

Const E2_NEG_SYMBOL

E2_NEG_SYMBOL: "↓" = "↓"

Const E2_POS_SYMBOL

E2_POS_SYMBOL: "↑" = "↑"

Const E2_SYMBOL

E2_SYMBOL: "e2" = "e2"

Const E31_NEG_SYMBOL

E31_NEG_SYMBOL: "⊷" = "⊷"

Const E31_POS_SYMBOL

E31_POS_SYMBOL: "⊶" = "⊶"

Const E31_SYMBOL

E31_SYMBOL: "e31" = "e31"

Const E3_NEG_SYMBOL

E3_NEG_SYMBOL: "⊗" = "⊗"

Const E3_POS_SYMBOL

E3_POS_SYMBOL: "⊙" = "⊙"

Const E3_SYMBOL

E3_SYMBOL: "e3" = "e3"

LOBMASK_BI

LOBMASK_BI: number = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I

LOBMASK_I

LOBMASK_I: number = 1 << 30

Const LOG_BASE

LOG_BASE: 7 = 7

Const LOG_MAX_INT

LOG_MAX_INT: number = Math.log(MAX_INT)

Const M1

M1: QQ = QQ.valueOf(-1, 1)

Const MAX_INT

MAX_INT: 9007199254740992 = 9007199254740992

Const MAX_INT_ARR

MAX_INT_ARR: number[] = smallToArray(MAX_INT)

Const PSEUDO_NEG_SYMBOL

PSEUDO_NEG_SYMBOL: "■" = "■"

Const PSEUDO_POS_SYMBOL

PSEUDO_POS_SYMBOL: "☐" = "☐"

Const PSEUDO_SYMBOL

PSEUDO_SYMBOL: "I" = "I"

Const R0

R0: QQ = QQ.valueOf(0, 1)

Const R1

R1: QQ = QQ.valueOf(1, 1)

Const R2

R2: QQ = QQ.valueOf(2, 1)

Const SCALAR_POS_SYMBOL

SCALAR_POS_SYMBOL: "1" = "1"

Const SCALAR_SYMBOL

SCALAR_SYMBOL: "1" = "1"

Const SYMBOLS_SI

SYMBOLS_SI: string[] = ['kg', 'm', 's', 'C', 'K', 'mol', 'cd']

Let abs

abs: abs = Math.abs

Let acos

acos: acos = Math.acos

Let asin

asin: asin = Math.asin

Let atan

atan: atan = Math.atan

Const config

config: Units = new Units()

Let cos

cos: cos = Math.cos

Const decodes

decodes: string[][] = [["F/m"],["S"],["F"],["C/kg"],["C/m ** 3"],["J/kg"],["Hz"],["A"],["m/s ** 2"],["m/s"],["kg·m/s"],["Pa"],["Pa·s"],["W/m ** 2"],["N/m"],["T"],["W/(m·K)"],["V/m"],["N"],["H/m"],["J/K"],["J/(kg·K)"],["J/(mol·K)"],["J/mol"],["J"],["J·s"],["W"],["V"],["Ω"],["H"],["Wb"]]

Let exp

exp: exp = Math.exp

Const highestPower2

highestPower2: number = powersOfTwo[powers2Length - 1]

Let log

log: log = Math.log

Const magicCode

magicCode: number = Math.random()

Const minusOne

minusOne: BigRational = bigRat(-1, 1)

Const one

one: BigRational = bigRat(1, 1)

Const patterns

patterns: number[][] = [[-1, 1, -3, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, 1], // F/m[-1, 1, -2, 1, 1, 1, 2, 1, 0, 1, 0, 1, 0, 1], // S[-1, 1, -2, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, 1], // F[-1, 1, +0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1], // C/kg[+0, 1, -3, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1], // C/m ** 3[+0, 1, 2, 1, -2, 1, 0, 1, 0, 1, 0, 1, 0, 1], // J/kg[+0, 1, 0, 1, -1, 1, 0, 1, 0, 1, 0, 1, 0, 1], // Hz[+0, 1, 0, 1, -1, 1, 1, 1, 0, 1, 0, 1, 0, 1], // A[0, 1, 1, 1, -2, 1, 0, 1, 0, 1, 0, 1, 0, 1], // m/s ** 2[0, 1, 1, 1, -1, 1, 0, 1, 0, 1, 0, 1, 0, 1], // m/s[1, 1, 1, 1, -1, 1, 0, 1, 0, 1, 0, 1, 0, 1], // kg·m/s[1, 1, -1, 1, -2, 1, 0, 1, 0, 1, 0, 1, 0, 1], // Pa[1, 1, -1, 1, -1, 1, 0, 1, 0, 1, 0, 1, 0, 1], // Pa·s[1, 1, 0, 1, -3, 1, 0, 1, 0, 1, 0, 1, 0, 1], // W/m ** 2[1, 1, 0, 1, -2, 1, 0, 1, 0, 1, 0, 1, 0, 1], // N/m[1, 1, 0, 1, -1, 1, -1, 1, 0, 1, 0, 1, 0, 1], // T[1, 1, 1, 1, -3, 1, 0, 1, -1, 1, 0, 1, 0, 1], // W/(m·K)[1, 1, 1, 1, -2, 1, -1, 1, 0, 1, 0, 1, 0, 1], // V/m[1, 1, 1, 1, -2, 1, 0, 1, 0, 1, 0, 1, 0, 1], // N[1, 1, 1, 1, 0, 1, -2, 1, 0, 1, 0, 1, 0, 1], // H/m[1, 1, 2, 1, -2, 1, 0, 1, -1, 1, 0, 1, 0, 1], // J/K[0, 1, 2, 1, -2, 1, 0, 1, -1, 1, 0, 1, 0, 1], // J/(kg·K)[1, 1, 2, 1, -2, 1, 0, 1, -1, 1, -1, 1, 0, 1], // J/(mol·K)[1, 1, 2, 1, -2, 1, 0, 1, 0, 1, -1, 1, 0, 1], // J/(mol)[1, 1, 2, 1, -2, 1, 0, 1, 0, 1, 0, 1, 0, 1], // J[1, 1, 2, 1, -1, 1, 0, 1, 0, 1, 0, 1, 0, 1], // J·s[1, 1, 2, 1, -3, 1, 0, 1, 0, 1, 0, 1, 0, 1], // W[1, 1, 2, 1, -2, 1, -1, 1, 0, 1, 0, 1, 0, 1], // V[1, 1, 2, 1, -1, 1, -2, 1, 0, 1, 0, 1, 0, 1], // Ω[1, 1, 2, 1, 0, 1, -2, 1, 0, 1, 0, 1, 0, 1], // H[1, 1, 2, 1, -1, 1, -1, 1, 0, 1, 0, 1, 0, 1] // Wb]

Const powers2Length

powers2Length: number = powersOfTwo.length

Const powersOfTwo

powersOfTwo: number[] = [1]

Let sin

sin: sin = Math.sin

Const sqrt

sqrt: sqrt = Math.sqrt

Let tan

tan: tan = Math.tan

Const zero

zero: BigRational = bigRat(0, 1)

Functions

add

  • add(a: number[], b: number[]): number[]

add00

  • add00(a00: number, a01: number, a10: number, a11: number, b00: number, b01: number, b10: number, b11: number): number

  • Parameters

    • a00: number
    • a01: number
    • a10: number
    • a11: number
    • b00: number
    • b01: number
    • b10: number
    • b11: number

    Returns number

add01

  • add01(a00: number, a01: number, a10: number, a11: number, b00: number, b01: number, b10: number, b11: number): number

  • Parameters

    • a00: number
    • a01: number
    • a10: number
    • a11: number
    • b00: number
    • b01: number
    • b10: number
    • b11: number

    Returns number

add10

  • add10(a00: number, a01: number, a10: number, a11: number, b00: number, b01: number, b10: number, b11: number): number

  • Parameters

    • a00: number
    • a01: number
    • a10: number
    • a11: number
    • b00: number
    • b01: number
    • b10: number
    • b11: number

    Returns number

add11

  • add11(a00: number, a01: number, a10: number, a11: number, b00: number, b01: number, b10: number, b11: number): number

  • Parameters

    • a00: number
    • a01: number
    • a10: number
    • a11: number
    • b00: number
    • b01: number
    • b10: number
    • b11: number

    Returns number

add4x4

  • add4x4(a: Float32Array, b: Float32Array, c: Float32Array): Float32Array

addAny

  • addAny(a: number[], b: number[]): number[]

addSmall

  • addSmall(a: number[], carry: number): number[]

appendCoord

  • appendCoord(coord: number, numberToString: (x: number) => string, label: string | string[], sb: string[]): void

appendLabel

  • appendLabel(coord: number, label: string | string[], sb: string[]): void

applyMixins

  • applyMixins(derivedCtor: any, baseCtors: any[]): void

arrayToSmall

  • arrayToSmall(arr: number[]): number | number[]

assertArgEuclidean1

  • assertArgEuclidean1(name: string, arg: G1): G1

assertArgNumber

  • assertArgNumber(name: string, x: number): number

assertArgRational

  • assertArgRational(name: string, arg: QQ): QQ

assertArgUnitOrUndefined

  • assertArgUnitOrUndefined(name: string, uom: Unit): Unit

b2

  • b2(t: number, begin: number, control: number, end: number): number

b2p0

  • b2p0(t: number, p: number): number

b2p1

  • b2p1(t: number, p: number): number

b2p2

  • b2p2(t: number, p: number): number

b3p0

  • b3p0(t: number, p: number): number

b3p1

  • b3p1(t: number, p: number): number

b3p2

  • b3p2(t: number, p: number): number

b3p3

  • b3p3(t: number, p: number): number

beANumber

  • beANumber(): string

beAString

  • beAString(): string

beAnArray

  • beAnArray(): string

beAnInteger

  • beAnInteger(): string

beBoolean

  • beBoolean(): string

beCanvasId

  • beCanvasId(): string

beDefined

  • beDefined(): string

beFunction

  • beFunction(): string

beObject

  • beObject(): string

beUndefined

  • beUndefined(): string

bigInt

  • bigInt(v?: number | string | Integer, radix?: number | string | Integer): any

bigRat

bitwise

clamp

  • clamp(x: number, min: number, max: number): number

compG2Get

compG2Set

  • compG2Set(m: GeometricE2, index: number, value: number): void

compG3Set

  • compG3Set(m: GeometricE3, index: number, value: number): void

compareAbs

  • compareAbs(a: number[], b: number[]): number

cosh

  • cosh(x: number): number

createArray

  • createArray(length: number): number[]

default

  • default(name: string, value: number, contextBuilder?: () => string): number

  • Computes the determinant of a 2x2 (square) matrix where the elements are assumed to be in column-major order. Computes the determinant of a 3x3 (square) matrix where the elements are assumed to be in column-major order. Computes the determinant of a 3x3 (square) matrix where the elements are assumed to be in column-major order. Computes the determinant of a 4x4 (square) matrix where the elements are assumed to be in column-major order. Computes the determinant of a 4x4 (square) matrix where the elements are assumed to be in column-major order. Computes a random number within the specified range. Computes a random number within the specified range. Sets this multivector to a rotor representing a rotation from a to b. R = (|b||a| + b * a) / sqrt(2 * |b||a|(|b||a| + b << a)) Returns undefined (void 0) if the vectors are anti-parallel. Sets this multivector to a rotor representing a rotation from a to b. R = (|b||a| + b * a) / sqrt(2 * |b||a|(|b||a| + b << a)) Returns undefined (void 0) if the vectors are anti-parallel. Sets this multivector to a rotor representing a rotation from a to b. R = (|b||a| + b * a) / sqrt(2 * |b||a|(|b||a| + b << a)) Returns undefined (void 0) if the vectors are anti-parallel. Sets this multivector to a rotor representing a rotation from a to b. R = (|b||a| + b * a) / sqrt(2 * |b||a|(|b||a| + b << a)) Returns undefined (void 0) if the vectors are anti-parallel.

    Parameters

    • name: string
    • value: number
    • Optional contextBuilder: () => string
        • (): string

        • Returns string

    Returns number

div

divMod1

  • divMod1(a: number[], b: number[]): (number | number[])[]

divMod2

  • divMod2(a: number[], b: number[]): (number | number[])[]

divModAny

divModSmall

  • divModSmall(value: number[], lambda: number): (number | number[])[]

dotVectorCartesianE2

  • dotVectorCartesianE2(ax: number, ay: number, bx: number, by: number): number

dotVectorCartesianE3

  • dotVectorCartesianE3(ax: number, ay: number, az: number, bx: number, by: number, bz: number): number

dotVectorE2

dotVectorE3

Const dumbString

  • dumbString(multiplier: number, formatted: string, dimensions: Dimensions, labels: string[], compact: boolean): string

exists

  • exists(v: any): boolean

expectArg

  • expectArg<T>(name: string, value: T): { toBeBoolean: any; toBeDefined: any; toBeFunction: any; toBeInClosedInterval: any; toBeNumber: any; toBeObject: any; toBeString: any; toBeUndefined: any; toNotBeNull: any; toSatisfy: any; value: any }

extE2

  • extE2(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • index: number

    Returns number

extE3

  • extE3(a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7: number, b0: number, b1: number, b2: number, b3: number, b4: number, b5: number, b6: number, b7: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • a4: number
    • a5: number
    • a6: number
    • a7: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • b4: number
    • b5: number
    • b6: number
    • b7: number
    • index: number

    Returns number

extG3

gauss

  • gauss(A: number[][], b: number[]): number[]

gcd

gcompE3

haveOwnProperty

  • haveOwnProperty(prop: string): (Anonymous function)

interpret

inv2x2

  • inv2x2(me: Float32Array, te: Float32Array): void

  • Computes the inverse of a 2x2 (square) matrix where the elements are assumed to be in column-major order.

    Parameters

    • me: Float32Array
    • te: Float32Array

    Returns void

inv3x3

  • inv3x3(m: Float32Array, te: Float32Array): void

  • Computes the inverse of a 2x2 (square) matrix where the elements are assumed to be in column-major order.

    Parameters

    • m: Float32Array
    • te: Float32Array

    Returns void

inv4x4

  • inv4x4(src: Float32Array, dest: Float32Array): void

  • Computes the inverse of a 4x4 (square) matrix where the elements are assumed to be in column-major order.

    Parameters

    • src: Float32Array
    • dest: Float32Array

    Returns void

isArray

  • isArray(x: any): boolean

isBasicPrime

  • isBasicPrime(v: Integer): boolean

isBoolean

  • isBoolean(x: any): boolean

isCallableMethod

  • isCallableMethod(x: any, name: string): boolean

isDefined

  • isDefined(arg: any): boolean

isFunction

  • isFunction(x: any): boolean

isInstance

  • isInstance(x: any): boolean

isInteger

  • isInteger(x: any): boolean

isLabelOne

  • isLabelOne(label: string | string[]): boolean

isNumber

  • isNumber(x: any): boolean

isObject

  • isObject(x: any): boolean

isPrecise

  • isPrecise(n: number): boolean

isString

  • isString(s: any): boolean

isUndefined

  • isUndefined(arg: any): boolean

isVariableName

  • isVariableName(name: string): boolean

lcm

lcoE2

  • lcoE2(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • index: number

    Returns number

lcoE3

  • lcoE3(a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7: number, b0: number, b1: number, b2: number, b3: number, b4: number, b5: number, b6: number, b7: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • a4: number
    • a5: number
    • a6: number
    • a7: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • b4: number
    • b5: number
    • b6: number
    • b7: number
    • index: number

    Returns number

lcoG3

makeColumnVector

  • makeColumnVector(n: number, v: number): number[]

makeUnaryUniversalFunction

  • makeUnaryUniversalFunction(methodName: string, primitiveFunction: (x: number) => number): (Anonymous function)

  • Parameters

    • methodName: string
    • primitiveFunction: (x: number) => number
        • (x: number): number

        • Parameters

          • x: number

          Returns number

    Returns (Anonymous function)

makeZeroBelow

  • makeZeroBelow(A: number[][], i: number, N: number): void

max

mergeStringMapList

  • mergeStringMapList<T>(ms: {}[]): {}

message

  • message(standard: string, override: () => string): string

min

mul

mul3x3

  • mul3x3(a: Float32Array, b: Float32Array, c: Float32Array): Float32Array

mul4x4

  • mul4x4(a: Float32Array, b: Float32Array, c: Float32Array): Float32Array

mulE2

  • mulE2(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • index: number

    Returns number

mulE3

  • mulE3(a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7: number, b0: number, b1: number, b2: number, b3: number, b4: number, b5: number, b6: number, b7: number, index: number): number

  • Multiplication of Geometric3. This was originally written for asm.

    Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • a4: number
    • a5: number
    • a6: number
    • a7: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • b4: number
    • b5: number
    • b6: number
    • b7: number
    • index: number

    Returns number

multiplyKaratsuba

  • multiplyKaratsuba(x: number[], y: number[]): number[]

multiplyLong

  • multiplyLong(a: number[], b: number[]): number[]

multiplySmall

  • multiplySmall(a: number[], b: number): number[]

multiplySmallAndArray

  • multiplySmallAndArray(a: number, b: number[], sign: boolean): BigInteger

mustBeBoolean

  • mustBeBoolean(name: string, value: boolean, contextBuilder?: () => string): boolean

mustBeCanvasId

  • mustBeCanvasId(name: string, value: number, contextBuilder?: () => string): number

mustBeDefined

  • mustBeDefined(name: string, value: any, contextBuilder?: () => string): any

mustBeFunction

  • mustBeFunction(name: string, value: any, contextBuilder?: () => string): any

mustBeInteger

  • mustBeInteger(name: string, value: number, contextBuilder?: () => string): number

mustBeObject

  • mustBeObject<T>(name: string, value: T, contextBuilder?: () => string): T

mustHaveOwnProperty

  • mustHaveOwnProperty(name: string, value: {}, prop: string, contextBuilder?: () => string): void

mustSatisfy

  • mustSatisfy(name: string, condition: boolean, messageBuilder: () => string, contextBuilder?: () => string): void

  • Parameters

    • name: string
    • condition: boolean
    • messageBuilder: () => string
        • (): string

        • Returns string

    • Optional contextBuilder: () => string
        • (): string

        • Returns string

    Returns void

Const parseBase

  • parseBase(text: string, base: number): any

parseDecimal

parseNumberValue

  • parseNumberValue(v: number): Integer

parseStringValue

  • parseStringValue(v: string): Integer

parseValue

quad

  • quad(x: number): number

quadSpinorE2

quadSpinorE3

quadVectorE2

  • quadVectorE2(vector: VectorE2): number

quadVectorE3

  • quadVectorE3(vector: VectorE3): number

randBetween

rcoE2

  • rcoE2(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • index: number

    Returns number

rcoE3

  • rcoE3(a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7: number, b0: number, b1: number, b2: number, b3: number, b4: number, b5: number, b6: number, b7: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • a4: number
    • a5: number
    • a6: number
    • a7: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • b4: number
    • b5: number
    • b6: number
    • b7: number
    • index: number

    Returns number

rcoG3

readOnly

reduce

roughLOB

rowWithMaximumInColumn

  • rowWithMaximumInColumn(A: number[][], column: number, N: number): number

scale

scpE2

  • scpE2(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • index: number

    Returns number

scpE3

  • scpE3(a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7: number, b0: number, b1: number, b2: number, b3: number, b4: number, b5: number, b6: number, b7: number, index: number): number

  • Scalar Product of Geometric3. This was originally written for asm. Note that all componenets except the zeroth are zero and so users can optimize.

    Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • a4: number
    • a5: number
    • a6: number
    • a7: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • b4: number
    • b5: number
    • b6: number
    • b7: number
    • index: number

    Returns number

scpG3

shiftLeft

  • shiftLeft(x: number[], n: number): number[]

shift_isSmall

  • shift_isSmall(n: number | string | BigInteger): boolean

sinh

  • sinh(x: number): number

smallToArray

  • smallToArray(n: number): number[]

solve

  • solve(A: number[][], N: number): number[]

square

  • square(a: number[]): number[]

squaredNormG3

stringFromCoordinates

  • stringFromCoordinates(coordinates: number[], numberToString: (x: number) => string, labels: (string | string[])[]): string

stringify

  • stringify(digit: Integer): string

sub

subE2

  • subE2(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, index: number): number

  • Parameters

    • a0: number
    • a1: number
    • a2: number
    • a3: number
    • b0: number
    • b1: number
    • b2: number
    • b3: number
    • index: number

    Returns number

subtract

  • subtract(a: number[], b: number[]): number[]

subtractAny

  • subtractAny(a: number[], b: number[], sign: boolean): Integer

subtractSmall

  • subtractSmall(a: number[], b: number, sign: boolean): Integer

swapRows

  • swapRows(A: number[][], i: number, j: number, N: number): void

tanh

  • tanh(x: number): number

toBase

toStringCustom

  • toStringCustom(coordinates: number[], uom: Unit, coordToString: (x: number) => string, labels: string[]): string

trim

  • trim(v: number[]): void

truncate

  • truncate(n: number): number

Const unitString

  • unitString(multiplier: number, formatted: string, dimensions: Dimensions, labels: string[], compact: boolean): string

useKaratsuba

  • useKaratsuba(l1: number, l2: number): boolean

wedgeXY

  • wedgeXY(ax: number, ay: number, az: number, bx: number, by: number, bz: number): number

  • Computes the z component of the cross-product of Cartesian vector components.

    Parameters

    • ax: number
    • ay: number
    • az: number
    • bx: number
    • by: number
    • bz: number

    Returns number

wedgeYZ

  • wedgeYZ(ax: number, ay: number, az: number, bx: number, by: number, bz: number): number

  • Computes the x component of the cross-product of Cartesian vector components.

    Parameters

    • ax: number
    • ay: number
    • az: number
    • bx: number
    • by: number
    • bz: number

    Returns number

wedgeZX

  • wedgeZX(ax: number, ay: number, az: number, bx: number, by: number, bz: number): number

  • Computes the y component of the cross-product of Cartesian vector components.

    Parameters

    • ax: number
    • ay: number
    • az: number
    • bx: number
    • by: number
    • bz: number

    Returns number

Object literals

mathcore

mathcore: object

acos

acos: (Anonymous function) = makeUnaryUniversalFunction('acos', acos)

asin

asin: (Anonymous function) = makeUnaryUniversalFunction('asin', asin)

atan

atan: (Anonymous function) = makeUnaryUniversalFunction('atan', atan)

cos

cos: (Anonymous function) = makeUnaryUniversalFunction('cos', cos)

cosh

cosh: (Anonymous function) = makeUnaryUniversalFunction('cosh', cosh)

exp

exp: (Anonymous function) = makeUnaryUniversalFunction('exp', exp)

log

log: (Anonymous function) = makeUnaryUniversalFunction('log', log)

norm

norm: (Anonymous function) = makeUnaryUniversalFunction('norm', abs)

quad

quad: (Anonymous function) = makeUnaryUniversalFunction('quad', quad)

sin

sin: (Anonymous function) = makeUnaryUniversalFunction('sin', sin)

sinh

sinh: (Anonymous function) = makeUnaryUniversalFunction('sinh', sinh)

sqrt

sqrt: (Anonymous function) = makeUnaryUniversalFunction('sqrt', sqrt)

tan

tan: (Anonymous function) = makeUnaryUniversalFunction('tan', tan)

tanh

tanh: (Anonymous function) = makeUnaryUniversalFunction('tanh', tanh)

Math

Math: object

cosh

cosh: cosh = cosh

sinh

sinh: sinh = sinh

Const scratch

scratch: object

a

a: number = 0

b

b: number = 0

x

x: number = 0

xy

xy: number = 0

y

y: number = 0

yz

yz: number = 0

z

z: number = 0

zx

zx: number = 0