To get help on a specific function from the console type:

    help FunctionName

# Commands

help

      help

      help FunctionName

  Print help (or help on a function/command).

load

      load "file.gel"

  Load a file into the interpretor.

cd

      cd /directory/name

  Change working directory.

pwd

      pwd

  Change working directory.

ls

      ls

  List files in the current directory.

plugin

      plugin plugin_name

  Load a plugin.

# Basic

Compose

      Compose (f,g)

  Compose two functions

GetCurrentModulo

      GetCurrentModulo

  Get current modulo from the context outside the function

Identity

      Identity (x)

  Identity function, returns its argument

IntegerFromBoolean

      IntegerFromBoolean (bval)

  Make integer (0 for `false` or 1 for `true`) from a boolean value. `bval` can also be a number in which case a non-zero value will be interpreted as `true` and zero will be interpretted as `false`.

IsBoolean

      IsBoolean (arg)

  Check if argument is a boolean (and not a number)

IsFunction

      IsFunction (arg)

  Check if argument is a function

IsFunctionRef

      IsFunctionRef (arg)

  Check if argument is a function reference

IsMatrix

      IsMatrix (arg)

  Check if argument is a matrix

IsNull

      IsNull (arg)

  Check if argument is a null

IsString

      IsString (arg)

  Check if argument is a text string

IsValue

      IsValue (arg)

  Check if argument is a number

SetFunctionFlags

      SetFunctionFlags (id,flags...)

  Set flags for a function, currently "PropagateMod" and "NoModuloArguments"

SetHelp

      SetHelp (id,category,desc)

  Set the category and help description line for a function

SetHelpAlias

      SetHelpAlias (id,alias)

  Sets up a help alias

chdir

      chdir (dir)

  Changes current directory

display

      display (str,expr)

  Display a string and an expression

error

      error (str)

  Prints a string to the error stream

exit

      exit

  Aliases: `quit`

  Exits the program

false

      false

  Aliases: `False` `FALSE`

  The false boolean value

manual

      manual

  Displays the user manual

print

      print (str)

  Prints an expression

printn

      printn (str)

  Prints an expression without a trailing newline

protect

      protect (id)

  Protect a variable from being modified

set

      set (id,val)

  Set a global variable. The `id` can be either a string or a quoted identifier as follows. For example:

      set(`x,1)

  will set the global variable `x` to the value 1.
string

      string (s)

  Make a string. This will make a string out of any argument.

true

      true

  Aliases: `True` `TRUE`

  The true boolean value

unprotect

      unprotect (id)

  Unprotect a variable from being modified

warranty

      warranty

  Gives the warranty information

# Parameters

ChopTolerance

      ChopTolerance = number

  Tolerance of the Chop function

ContinuousNumberOfTries

      ContinuousNumberOfTries = number

  How many iterations to try to find the limit for continuity and limits

ContinuousSFS

      ContinuousSFS = number

  How many successive steps to be within tolerance for calculation of continuity

ContinuousTolerance

      ContinuousTolerance = number

  Tolerance for continuity of functions and for calculating the limit

DerivativeNumberOfTries

      DerivativeNumberOfTries = number

  How many iterations to try to find the limit for derivative

DerivativeSFS

      DerivativeSFS = number

  How many successive steps to be within tolerance for calculation of derivative

DerivativeTolerance

      DerivativeTolerance = number

  Tolerance for calculating the derivatives of functions

ErrorFunctionTolerance

      ErrorFunctionTolerance = number

  Tolerance of the ErrorFunction

FloatPrecision

      FloatPrecision = number

  Floating point precision

FullExpressions

      FullExpressions = boolean

  Print full expressions, even if more than a line

GaussDistributionTolerance

      GaussDistributionTolerance = number

  Tolerance of the GaussDistribution function

IntegerOutputBase

      IntegerOutputBase = number

  Integer output base

IsPrimeMillerRabinReps

      IsPrimeMillerRabinReps = number

  Number of extra Miller-Rabin tests to run on a number before declaring it a prime in IsPrime

MaxDigits

      MaxDigits = number

  Maximum digits to display

MaxErrors

      MaxErrors = number

  Maximum errors to display

MixedFractions

      MixedFractions = boolean

  If true, mixed fractions are printed

NumericalIntegralFunction

      NumericalIntegralFunction = function

  The function used for numerical integration in NumericalIntegral

NumericalIntegralSteps

      NumericalIntegralSteps = number

  Steps to perform in NumericalIntegral

OutputStyle

      OutputStyle = string

  Output style, this can be normal, latex, mathml or troff.

  This affects mostly how matrices and fractions are printed out and is useful for pasting into documents. For example you can set this to the latex by:

      OutputStyle = "latex"

ResultsAsFloats

      ResultsAsFloats = boolean

  Convert all results to floats before printing

ScientificNotation

      ScientificNotation = boolean

  Use scientific notation

SumProductNumberOfTries

      SumProductNumberOfTries = number

  How many iterations to try for InfiniteSum and InfiniteProduct

SumProductSFS

      SumProductSFS = number

  How many successive steps to be within tolerance for InfiniteSum and InfiniteProduct

SumProductTolerance

      SumProductTolerance = number

  Tolerance for InfiniteSum and InfiniteProduct

# Constants

EulerConstant

      EulerConstant

  Aliases: `gamma`

  Euler's Constant gamma. Sometimes called the Euler-Mascheroni constant.

  See Planetmath or Mathworld for more information.

GoldenRatio

      GoldenRatio

  The Golden Ratio

  See Planetmath or Mathworld for more information.

Gravity

      Gravity

  Free fall acceleration

e

      e

  The base of the natural logarithm. `e^x` is the exponential function exp. This is the number approximately 2.71828182846...

  See Planetmath or Mathworld for more information.

pi

      pi

  The number pi, that is the ratio of a circle's circumference to it's diameter. This is approximately 3.14159265359...

  See Planetmath or Mathworld for more information.

# Numeric

AbsoluteValue

      AbsoluteValue (x)

  Aliases: `abs`

  Absolute value of a number and if `x` is a complex value the modulus of `x`.

  See Mathworld for more information.

Chop

      Chop (x)

  Replace very small number with zero

ComplexConjugate

      ComplexConjugate (M)

  Aliases: `conj` `Conj`

  Calculates the conjugate

Denominator

      Denominator (x)

  Get the denominator of a rational number

FractionalPart

      FractionalPart (x)

  Return the fractional part of a number

Im

      Im (z)

  Aliases: `ImaginaryPart`

  Get the imaginary part of a complex number

IntegerQuotient

      IntegerQuotient (m,n)

  Division w/o remainder

IsComplex

      IsComplex (num)

  Check if argument is a complex (non-real) number

IsComplexRational

      IsComplexRational (num)

  Check if argument is a possibly complex rational number

IsFloat

      IsFloat (num)

  Check if argument is a floating point number (non-complex)

IsGaussInteger

      IsGaussInteger (num)

  Aliases: `IsComplexInteger`

  Check if argument is a possibly complex integer

IsGaussianInteger

      IsGaussianInteger (z)

  Check if argument is a gaussian integer

IsInteger

      IsInteger (num)

  Check if argument is an integer (non-complex)

IsNonNegativeInteger

      IsNonNegativeInteger (num)

  Check if argument is a non-negative real integer.

IsPositiveInteger

      IsPositiveInteger (num)

  Aliases: `IsNaturalNumber`

  Check if argument is a positive real integer.

IsRational

      IsRational (num)

  Check if argument is a rational number (non-complex)

IsReal

      IsReal (num)

  Check if argument is a real number

Numerator

      Numerator (x)

  Get the numerator of a rational number

Re

      Re (z)

  Aliases: `RealPart`

  Get the real part of a complex number

Sign

      Sign (x)

  Aliases: `sign`

  Return the sign of a number. That is returns `-1` if value is negative, `0` if value is zero and `1` if value is positive. If `x` is a complex value then `Sign` returns the direction or 0.

ceil

      ceil (x)

  Aliases: `Ceiling`

  Get the lowest integer more than or equal to n

exp

      exp (x)

  The exponential function. This is the function `e^x` where `e` is the base of the natural logarithm.

  See Planetmath or Mathworld for more information.

float

      float (x)

  Make number a floating point value. That is returns the floating point representation of the number `x`.

floor

      floor (x)

  Aliases: `Floor`

  Get the highest integer less than or equal to n

ln

      ln (x)

  The natural logarithm, the logarithm to base `e`.

log

      log (x,b...)

  Logarithm of `x` base `b` (calls `DiscreteLog` if in modulo mode), if base is not given, `e` is used.

log10

      log10 (x)

  Logarithm of x base 10

log2

      log2 (x)

  Aliases: `lg`

  Logarithm of x base 2

max

      max (a,args...)

  Aliases: `Max` `Maximum`

  Returns the maximum of arguments or matrix

min

      min (a,args...)

  Aliases: `Min` `Minimum`

  Returns the minimum of arguments or matrix

rand

      rand (size...)

  Generate random float in the range `[0,1)`. If size is given then a matrix (if two numbers are specified) or vector (if one number is specified) of the given size returned.

randint

      randint (max,size...)

  Generate random integer in the range `[0,max)`. If size is given then a matrix (if two numbers are specified) or vector (if one number is specified) of the given size returned. For example

      genius> randint(4)
      = 3
      genius> randint(4,2)
      =
      [0      1]
      genius> randint(4,2,3)
      =
      [2      2       1
       0      0       3]

round

      round (x)

  Aliases: `Round`

  Round a number

sqrt

      sqrt (x)

  Aliases: `SquareRoot`

  The square root. When operating modulo some integer will return either a `null` or a vector of the square roots. Examples:

      genius> sqrt(2)
      = 1.41421356237
      genius> sqrt(-1)
      = 1i
      genius> sqrt(4) mod 7
      =
      [2      5]
      genius> 2*2 mod 7
      = 4

  See Planetmath for more information.

trunc

      trunc (x)

  Aliases: `Truncate` `IntegerPart`

  Truncate number to an integer (return the integer part)

# Trigonometry

acos

      acos (x)

  Aliases: `arccos`

  The arccos (reverse cos) function

acosh

      acosh (x)

  Aliases: `arccosh`

  The arccosh (reverse cosh) function

acot

      acot (x)

  Aliases: `arccot`

  The arccot (reverse cot) function

acoth

      acoth (x)

  Aliases: `arccoth`

  The arccoth (reverse coth) function

acsc

      acsc (x)

  Aliases: `arccsc`

  The reverse cosecant function

acsch

      acsch (x)

  Aliases: `arccsch`

  The reverse hyperbolic cosecant function

asec

      asec (x)

  Aliases: `arcsec`

  The reverse secant function

asech

      asech (x)

  Aliases: `arcsech`

  The reverse hyperbolic secant function

asin

      asin (x)

  Aliases: `arcsin`

  The arcsin (reverse sin) function

asinh

      asinh (x)

  Aliases: `arcsinh`

  The arcsinh (reverse sinh) function

atan

      atan (x)

  Aliases: `arctan`

  Calculates the arctan function

atanh

      atanh (x)

  Aliases: `arctanh`

  The arctanh (reverse tanh) function

cos

      cos (x)

  Calculates the cosine function.

  See Planetmath for more information.

cosh

      cosh (x)

  Calculates the hyperbolic cosine function

  See Planetmath for more information.

cot

      cot (x)

  The cotangent function

  See Planetmath for more information.

coth

      coth (x)

  The hyperbolic cotangent function

  See Planetmath for more information.

csc

      csc (x)

  The cosecant function

  See Planetmath for more information.

csch

      csch (x)

  The hyperbolic cosecant function

  See Planetmath for more information.

sec

      sec (x)

  The secant function

  See Planetmath for more information.

sech

      sech (x)

  The hyperbolic secant function

  See Planetmath for more information.

sin

      sin (x)

  Calculates the sine function.

  See Planetmath for more information.

sinh

      sinh (x)

  Calculates the hyperbolic sine function

  See Planetmath for more information.

tan

      tan (x)

  Calculates the tan function

  See Planetmath for more information.

tanh

      tanh (x)

  The hyperbolic tangent function

  See Planetmath for more information.

# Number Theory

AreRelativelyPrime

      AreRelativelyPrime (a,b)

  Are the real integers `a` and `b` relatively prime? Returns true or false.

  See Mathworld for more information.

BernoulliNumber

      BernoulliNumber (n)

  Return the `n`th Bernoulli number

ChineseRemainder

      ChineseRemainder (a,m)

  Aliases: `CRT`

  Find the `x` that solves the system given by the vector `a` and modulo the elements of `m`, using the Chinese Remainder Theorem.

  See Planetmath or Mathworld for more information.

CombineFactorizations

      CombineFactorizations (a,b)

  Given two factorizations, give the factorization of the product.

  See Factorize.

ConvertFromBase

      ConvertFromBase (v,b)

  Convert a vector of values indicating powers of b to a number

ConvertToBase

      ConvertToBase (n,b)

  Convert a number to a vector of powers for elements in base b

DiscreteLog

      DiscreteLog (n,b,q)

  Find discrete log of n base b in F_q where q is a prime using the Silver-Pohlig-Hellman algoritm

  See Mathworld for more information.

Divides

      Divides (m,n)

  Checks divisibility (if m divides n)

EulerPhi

      EulerPhi (n)

  Compute the Euler phi function for `n`, that is the number of integers between 1 and `n` relatively prime to `n`.

  See Planetmath or Mathworld for more information.

ExactDivision

      ExactDivision (n,d)

  Return `n/d` but only if `d` divides `n`. If `d` does not divide `n` then this function returns garbage. This is a lot faster for very large numbers than the operation `n/d`, but of course only useful if you know that the division is exact.

Factorize

      Factorize (n)

  Return factorization of a number as a matrix. The first row is the primes in the factorization (including 1) and the second row are the powers. So for example:

      genius> Factorize(11*11*13)
      =
      [1      11      13
       1      2       1]

Factors

      Factors (n)

  Return all factors of `n` in a vector. This includes all the non-prime factors as well. It includes 1 and the number itself. So for example to print all the perfect numbers (those that are sums of their factors) up to the number 1000 you could do (this is of course very inefficent)

      for n=1 to 1000 do (
          if MatrixSum (Factors(n)) == 2*n then
              print(n)
      )

FermatFactorization

      FermatFactorization (n,tries)

  Attempt fermat factorization of `n` into `(t-s)*(t+s)`, returns `t` and `s` as a vector if possible, null otherwise. `tries` specifies the number of tries before giving up.

  This is a fairly good factorization if your number is the product of two factors that are very close to each other.

FindPrimitiveElementMod

      FindPrimitiveElementMod (q)

  Find the first primitive element in F_q (q must be a prime)

FindRandomPrimitiveElementMod

      FindRandomPrimitiveElementMod (q)

  Find a random primitive element in F_q (q must be a prime)

IndexCalculus

      IndexCalculus (n,b,q,S)

  Compute discrete log base b of n in F_q (q a prime) using the factor base S. S should be a column of primes possibly with second column precalculated by IndexCalculusPrecalculation.

IndexCalculusPrecalculation

      IndexCalculusPrecalculation (b,q,S)

  Run the precalculation step of IndexCalculus for logarithms base b in F_q (q a prime) for the factor base S (where S is a column vector of primes). The logs will be precalculated and returned in the second column.

IsEven

      IsEven (n)

  Tests if an integer is even.

IsNthPower

      IsNthPower (m,n)

  Tests if a rational number `m` is a perfect `n`th power. See also IsPerfectPower and IsPerfectSquare.

IsOdd

      IsOdd (n)

  Tests if an integer is odd

IsPerfectPower

      IsPerfectPower (n)

  Check a number for being any perfect power (a^b)

IsPerfectSquare

      IsPerfectSquare (n)

  Check a number for being a perfect square. The number must be a real integer. Negative integers are of course never perfect squares.

IsPrime

      IsPrime (n)

  Tests primality of integers, for numbers less than 25*10^9 the answer is deterministic (if Riemann hypothesis is true). For numbers larger, the probability of a false positive depends on `IsPrimeMillerRabinReps`. That is the probability of false positive is 1/4 to the power `IsPrimeMillerRabinReps`. The default value of 22 yields a probability of about 5.7e-14.

  If `false` is returned, you can be sure that the number is a composite. If you want to be absolutely sure that you have a prime you can use `MillerRabinTestSure` but it may take a lot longer.

  See Mathworld for more information.

IsPrimitiveMod

      IsPrimitiveMod (g,q)

  Check if g is primitive in F_q, where q is a prime. If q is not prime results are bogus.

IsPrimitiveModWithPrimeFactors

      IsPrimitiveModWithPrimeFactors (g,q,f)

  Check if g is primitive in F_q, where q is a prime and f is a vector of prime factors of q-1. If q is not prime results are bogus.

IsPseudoprime

      IsPseudoprime (n,b)

  If n is a pseudoprime base b but not a prime, that is if b^(n-1) == 1 mod n

IsStrongPseudoprime

      IsStrongPseudoprime (n,b)

  Test if n is a strong pseudoprime to base b but not a prime

Jacobi

      Jacobi (a,b)

  Aliases: `JacobiSymbol`

  Calculate the Jacobi symbol (a/b) (b should be odd)

JacobiKronecker

      JacobiKronecker (a,b)

  Aliases: `JacobiKroneckerSymbol`

  Calculate the Jacobi symbol (a/b) with the Kronecker extension (a/2)=(2/a) when a odd, or (a/2)=0 when a even

LeastAbsoluteResidue

      LeastAbsoluteResidue (a,n)

  Return the residue of a mod n with the least absolute value (in the interval -n/2 to n/2)

Legendre

      Legendre (a,p)

  Aliases: `LegendreSymbol`

  Calculate the Legendre symbol (a/p).

  See Mathworld for more information.

LucasLehmer

      LucasLehmer (p)

  Test if Mp is a Mersenne prime using the Lucas-Lehmer test

  See Mathworld for more information.

LucasNumber

      LucasNumber (n)

  Returns the n'th Lucas number

  See Mathworld for more information.

MaximalPrimePowerFactors

      MaximalPrimePowerFactors (n)

  Return all maximal prime power factors of a number

MillerRabinTest

      MillerRabinTest (n,reps)

  Use the Miller-Rabin primality test on `n`, `reps` number of times. The probability of false positive is `(1/4)^reps`. It is probably usually better to use `IsPrime` since that is faster and better on smaller integers.

  See Mathworld for more information.

MillerRabinTestSure

      MillerRabinTestSure (n)

  Use the Miller-Rabin primality test on `n` with enough bases that assuming the Generalized Reimann Hypothesis the result is deterministic.

  See Mathworld for more information.

ModInvert

      ModInvert (n,m)

  Returns inverse of n mod m

MoebiusMu

      MoebiusMu (n)

  Return the Moebius mu function evaluated in `n`. That is, it returns 0 if `n` is not a product of distinct primes and `(-1)^k` if it is a product of `k` distinct primes.

  See Mathworld for more information.

NextPrime

      NextPrime (n)

  Returns the least prime greater than `n`. Negatives of primes are considered prime and so to get the previous prime you can use `-NextPrime(-n)`.

  This uses the GMP's `mpz_nextprime` which in turn uses the probabilistic Miller-Rabin test. The probability of false positive is not tunable, but is low enough for all practical purposes.

PadicValuation

      PadicValuation (n,p)

  Returns the padic valuation (number of trailing zeros in base p).

PowerMod

      PowerMod (a,b,m)

  Compute a^b mod m

Prime

      Prime (n)

  Aliases: `prime`

  Return the n'th prime (up to a limit)

  See Mathworld for more information.

PrimeFactors

      PrimeFactors (n)

  Return all prime factors of a number

PseudoprimeTest

      PseudoprimeTest (n,b)

  Pseudoprime test, true iff b^(n-1) == 1 (mod n)

RemoveFactor

      RemoveFactor (n,m)

  Removes all instances of the factor m from the number n

SilverPohligHellmanWithFactorization

      SilverPohligHellmanWithFactorization (n,b,q,f)

  Find discrete log of n base b in F_q where q is a prime using the Silver-Pohlig-Hellman algoritm, given f being the factorization of q-1

SqrtModPrime

      SqrtModPrime (n,p)

  Find square root of n mod p (a prime). Null is returned if not a quadratic residue.

StrongPseudoprimeTest

      StrongPseudoprimeTest (n,b)

  Run the strong pseudoprime test base b on n

gcd

      gcd (a,args...)

  Aliases: `GCD`

  Greatest common divisor of integers. You can enter as many integers in the argument list, or you can give a vector or a matrix of integers. If you give more than one matrix of the same size then GCD is done element by element.

  See Mathworld for more information.

lcm

      lcm (a,args...)

  Aliases: `LCM`

  Least common multiplier of integers. You can enter as many integers in the argument list, or you can give a vector or a matrix of integers. If you give more than one matrix of the same size then LCM is done element by element.

  See Mathworld for more information.

# Matrix Manipulation

ApplyOverMatrix

      ApplyOverMatrix (a,func)

  Apply a function over all entries of a matrix and return a matrix of the results

ApplyOverMatrix2

      ApplyOverMatrix2 (a,b,func)

  Apply a function over all entries of 2 matrices (or 1 value and 1 matrix) and return a matrix of the results

ColumnsOf

      ColumnsOf (M)

  Gets the columns of a matrix as a horizontal vector

ComplementSubmatrix

      ComplementSubmatrix (m,r,c)

  Remove column(s) and row(s) from a matrix

CompoundMatrix

      CompoundMatrix (k,A)

  Calculate the kth compund matrix of A

DeleteColumn

      DeleteColumn (M,col)

  Delete a column of a matrix

DeleteRow

      DeleteRow (M,row)

  Delete a row of a matrix

DiagonalOf

      DiagonalOf (M)

  Gets the diagonal entries of a matrix as a horizontal vector

DotProduct

      DotProduct (u,v)

  Aliases: `InnerProduct`

  Get the dot product of two vectors

ExpandMatrix

      ExpandMatrix (M)

  Expands a matrix just like we do on unquoted matrix input

I

      I (n)

  Aliases: `eye`

  Make an identity matrix of a given size

IndexComplement

      IndexComplement (vec,msize)

  Return the index complement of a vector of indexes

IsDiagonal

      IsDiagonal (M)

  Is a matrix diagonal

IsLowerTriangular

      IsLowerTriangular (M)

  Is a matrix lower triangular

IsMatrixInteger

      IsMatrixInteger (M)

  Check if a matrix is an integer (non-complex) matrix

IsMatrixRational

      IsMatrixRational (M)

  Check if a matrix is a rational (non-complex) matrix

IsMatrixReal

      IsMatrixReal (M)

  Check if a matrix is a real (non-complex) matrix

IsMatrixSquare

      IsMatrixSquare (M)

  Is a matrix square

IsUpperTriangular

      IsUpperTriangular (M)

  Is a matrix upper triangular

IsValueOnly

      IsValueOnly (M)

  Check if a matrix is a matrix of numbers

IsVector

      IsVector (v)

  Is argument a horizontal or a vertical vector

LowerTriangular

      LowerTriangular (M)

  Zero out entries above the diagonal

MakeDiagonal

      MakeDiagonal (v,arg...)

  Aliases: `diag`

  Make diagonal matrix from a vector

MatrixProduct

      MatrixProduct (a)

  Calculate the product of all elements in a matrix

MatrixSum

      MatrixSum (a)

  Calculate the sum of all elements in a matrix

MatrixSumSquares

      MatrixSumSquares (a)

  Calculate the sum of squares of all elements in a matrix

OuterProduct

      OuterProduct (u,v)

  Get the outer product of two vectors

ReverseVector

      ReverseVector (v)

  Reverse elements in a vector

RowSum

      RowSum (m)

  Calculate sum of each row in a matrix

RowSumSquares

      RowSumSquares (m)

  Calculate sum of squares of each row in a matrix

RowsOf

      RowsOf (M)

  Gets the rows of a matrix as a vertical vector

SetMatrixSize

      SetMatrixSize (M,rows,columns)

  Make new matrix of given size from old one

SortVector

      SortVector (v)

  Sort vector elements

StripZeroColumns

      StripZeroColumns (M)

  Removes any all-zero columns of M

StripZeroRows

      StripZeroRows (M)

  Removes any all-zero rows of M

Submatrix

      Submatrix (m,r,c)

  Return column(s) and row(s) from a matrix

SwapRows

      SwapRows (m,row1,row2)

  Swap two rows in a matrix

UpperTriangular

      UpperTriangular (M)

  Zero out entries below the diagonal

columns

      columns (M)

  Get the number of columns of a matrix

elements

      elements (M)

  Get the number of elements of a matrix

ones

      ones (rows,columns...)

  Make an matrix of all ones (or a row vector)

rows

      rows (M)

  Get the number of rows of a matrix

zeros

      zeros (rows,columns...)

  Make an matrix of all zeros (or a row vector)

# Linear Algebra

AuxilliaryUnitMatrix

      AuxilliaryUnitMatrix (n)

  Get the auxilliary unit matrix of size n

BilinearForm

      BilinearForm (v,A,w)

  Evaluate (v,w) with respect to the bilinear form given by the matrix A

BilinearFormFunction

      BilinearFormFunction (A)

  Return a function that evaluates two vectors with respect to the bilinear form given by A

CharacteristicPolynomial

      CharacteristicPolynomial (M)

  Aliases: `CharPoly`

  Get the characteristic polynomial as a vector

CharacteristicPolynomialFunction

      CharacteristicPolynomialFunction (M)

  Get the characteristic polynomial as a function

ColumnSpace

      ColumnSpace (M)

  Get a basis matrix for the columnspace of a matrix

CompanionMatrix

      CompanionMatrix (p)

  Companion matrix of a polynomial (as vector)

ConjugateTranspose

      ConjugateTranspose (M)

  Conjugate transpose of a matrix (adjoint)

Convolution

      Convolution (a,b)

  Aliases: `convol`

  Calculate convolution of two horizontal vectors

ConvolutionVector

      ConvolutionVector (a,b)

  Calculate convolution of two horizontal vectors

CrossProduct

      CrossProduct (v,w)

  CrossProduct of two vectors in R^3

DeterminantalDivisorsInteger

      DeterminantalDivisorsInteger (M)

  Get the determinantal divisors of an integer matrix (not its characteristic)

DirectSum

      DirectSum (M,N...)

  Direct sum of matrices

DirectSumMatrixVector

      DirectSumMatrixVector (v)

  Direct sum of a vector of matrices

Eigenvalues

      Eigenvalues (M)

  Aliases: `eig`

  Get the eigenvalues of a matrix (Currently only for 2x2 and triangular matrices)

GramSchmidt

      GramSchmidt (v,B)

  Apply the Gram-Schmidt process (to the columns) with respect to innter product given by #2

GramSchmidtDot

      GramSchmidtDot (M)

  Apply the Gram-Schmidt process (to the columns) using the dot product

HankelMatrix

      HankelMatrix (c,r)

  Hankel matrix

HilbertMatrix

      HilbertMatrix (n)

  Hilbert matrix of order n

Image

      Image (T)

  Get the image (columnspace) of a linear transform

InfNorm

      InfNorm (v)

  Get the Inf Norm of a vector

InvariantFactorsInteger

      InvariantFactorsInteger (M)

  Get the invariant factors of a square integer matrix (not its characteristic)

InverseHilbertMatrix

      InverseHilbertMatrix (n)

  Inverse Hilbert matrix of order n

IsHermitian

      IsHermitian (M)

  Is a matrix hermitian

IsInSubspace

      IsInSubspace (v,W)

  Test if a vector is in a subspace

IsInvertible

      IsInvertible (n)

  Is a matrix (or number) invertible (Integer matrix is invertible iff it's invertible over the integers)

IsInvertibleField

      IsInvertibleField (n)

  Is a matrix (or number) invertible over a field

IsNormal

      IsNormal (M)

  Is a matrix normal

IsSkewHermitian

      IsSkewHermitian (M)

  Is a matrix skew-hermitian

IsUnitary

      IsUnitary (M)

  Is a matrix unitary

JordanBlock

      JordanBlock (n,lambda)

  Aliases: `J`

  Get the jordan block corresponding to lambda and n

Kernel

      Kernel (T)

  Get the kernel (nullspace) of a linear transform

LUDecomposition

      LUDecomposition (A, L, U)

  Get the LU decomposition of `A` and store the result in the `L` and `U` which should be references. It returns null. For example suppose that A is a square matrix, then after running:

      genius> LUDecomposition(A,&L,&U)

  You will have the lower matrix stored in a variable called `L` and the upper matrix in a variable called `U`.

  This is the LU decomposition of a matrix aka Crout and/or Cholesky reduction. (ISBN 0-201-11577-8 pp.99-103) The upper triangular matrix features a diagonal of values 1 (one). This is not Doolittle's Method which features the 1's diagonal on the lower matrix.

  Not all matrices have LU decompositions, for example `[0,1;1,0]` does not and this function returns `false` in this case and sets `L` and `U` to null.

  See Mathworld for more information.

Minor

      Minor (M,i,j)

  Get the i-j minor of a matrix

NonPivotColumns

      NonPivotColumns (M)

  Return the columns that are not the pivot columns of a matrix

Norm

      Norm (v,p...)

  Aliases: `norm`

  Get the p Norm (or 2 Norm if no p is supplied) of a vector

NullSpace

      NullSpace (T)

  Get the nullspace of a matrix

Nullity

      Nullity (M)

  Aliases: `nullity`

  Get the nullity of a matrix

OrthogonalComplement

      OrthogonalComplement (M)

  Get the orthogonal complement of the columnspace

PivotColumns

      PivotColumns (M)

  Return pivot columns of a matrix, that is columns which have a leading 1 in rref form, also returns the row where they occur

Projection

      Projection (v,W,B)

  Projection of vector v onto subspace W given a bilinear form B

RaleighQuotient

      RaleighQuotient (A,x)

  Return the Raleigh Quotient of a matrix and a vector

Rank

      Rank (M)

  Aliases: `rank`

  Get the rank of a matrix

RosserMatrix

      RosserMatrix ()

  Rosser matrix, a classic symmetric eigenvalue test problem

Rotation2D

      Rotation2D (angle)

  Aliases: `RotationMatrix`

  Rotation around origin in R^2

Rotation3DX

      Rotation3DX (angle)

  Rotation around origin in R^3 about the x-axis

Rotation3DY

      Rotation3DY (angle)

  Rotation around origin in R^3 about the y-axis

Rotation3DZ

      Rotation3DZ (angle)

  Rotation around origin in R^3 about the z-axis

RowSpace

      RowSpace (M)

  Get a basis matrix for the rowspace of a matrix

SmithNormalFormField

      SmithNormalFormField (A)

  Smith Normal Form for fields (will end up with 1's on the diagonal)

SmithNormalFormInteger

      SmithNormalFormInteger (M)

  Smith Normal Form for square integer matrices (not its characteristic)

SolveLinearSystem

      SolveLinearSystem (M,V,args...)

  Solve linear system Mx=V, return solution V if there is a unique solution, null otherwise. Extra two reference parameters can optionally be used to get the reduced M and V.

Trace

      Trace (m)

  Aliases: `trace`

  Calculate the trace of a matrix

Transpose

      Transpose (M)

  Transpose of a matrix

VandermondeMatrix

      VandermondeMatrix (v)

  Aliases: `vander`

  Return the Vandermonde matrix

VectorAngle

      VectorAngle (v,w,B)

  The angle of two vectors, given an inner product

VectorSpaceDirectSum

      VectorSpaceDirectSum (M,N)

  The direct sum of the vector spaces M and N

VectorSubspaceIntersection

      VectorSubspaceIntersection (M,N)

  Intersection of the subspaces given by M and N

VectorSubspaceSum

      VectorSubspaceSum (M,N)

  The sum of the vector spaces M and N, that is {w | w=m+n, m in M, n in N}

adj

      adj (m)

  Aliases: `Adjugate`

  Get the classical adjoint (adjugate) of a matrix

cref

      cref (M)

  Aliases: `CREF` `ColumnReducedEchelonForm`

  Compute the Column Reduced Echelon Form

det

      det (M)

  Aliases: `Determinant`

  Get the determinant of a matrix

ref

      ref (M)

  Aliases: `REF` `RowEchelonForm`

  Get the row echelon form of a matrix

rref

      rref (M)

  Aliases: `RREF` `ReducedRowEchelonForm`

  Get the reduced row echelon form of a matrix

# Combinatorics

Catalan

      Catalan (n)

  Get n'th catalan number

Combinations

      Combinations (k,n)

  Get all combinations of k numbers from 1 to n as a vector of vectors

DoubleFactorial

      DoubleFactorial (n)

  Double factorial: n(n-2)(n-4)...

Factorial

      Factorial (n)

  Factorial: n(n-1)(n-2)...

FallingFactorial

      FallingFactorial (n,k)

  Falling factorial: (n)_k = n(n-1)...(n-(k-1))

Fibbonachi

      Fibbonachi (x)

  Aliases: `fib`

  Calculate `n`th fibbonachi number. That is the number defined recursively by `Fibbonachi(n) = Fibbonachi(n-1) + Fibbonachi(n-2)` and `Fibbonachi(1) = Fibbonachi(2) = 1`.

  See Mathworld for more information.

GaloisMatrix

      GaloisMatrix (combining_rule)

  Galois matrix given a linear combining rule (a_1*x_+...+a_n*x_n=x_(n+1))

HarmonicNumber

      HarmonicNumber (n,r)

  Aliases: `HarmonicH`

  Harmonic Number, the nth harmonic number of order r

Hofstadter

      Hofstadter (n)

  Hofstadter's function q(n) defined by q(1)=1, q(2)=1, q(n)=q(n-q(n-1))+q(n-q(n-2))

LinearRecursiveSequence

      LinearRecursiveSequence (seed_values,combining_rule,n)

  Compute linear recursive sequence using galois stepping

Multinomial

      Multinomial (v,arg...)

  Calculate multinomial coefficients

Pascal

      Pascal (i)

  Get the pascal's triangle as a matrix

Permutations

      Permutations (k,n)

  Get all permutations of k numbers from 1 to n as a vector of vectors

RisingFactorial

      RisingFactorial (n,k)

  Aliases: `Puchhammer`

  (Puchhammer) Rising factorial: (n)_k = n(n+1)...(n+(k-1))

Subfactorial

      Subfactorial (n)

  Subfactorial: n! times sum_{k=1}^n (-1)^k/k!

Triangular

      Triangular (nth)

  Calculate the nth triangular number

nCr

      nCr (n,r)

  Aliases: `Binomial`

  Calculate combinations (binomial coefficient)

nPr

      nPr (n,r)

  Calculate permutations

# Calculus

CompositeSimpsonsRule

      CompositeSimpsonsRule (f,a,b,n)

  Integration of f by Composite Simpson's Rule on the interval [a,b] with n subintervals with error of max(f'''')*h^4*(b-a)/180, note that n should be even

CompositeSimpsonsRuleTolerance

      CompositeSimpsonsRuleTolerance (f,a,b,FourthDerivativeBound,Tolerance)

  Integration of f by Composite Simpson's Rule on the interval [a,b] with the number of steps calculated by the fourth derivative bound and the desired tolerance

InfiniteProduct

      InfiniteProduct (func,start,inc)

  Try to calculate an infinite product for a single parameter function

InfiniteProduct2

      InfiniteProduct2 (func,arg,start,inc)

  Try to calculate an infinite product for a double parameter function with func(arg,n)

InfiniteSum

      InfiniteSum (func,start,inc)

  Try to calculate an infinite sum for a single parameter function

InfiniteSum2

      InfiniteSum2 (func,arg,start,inc)

  Try to calculate an infinite sum for a double parameter function with func(arg,n)

IsContinuous

      IsContinuous (f,x0)

  Try and see if a real-valued function is continuous at x0 by calculating the limit there

IsDifferentiable

      IsDifferentiable (f,x0)

  Test for differentiability by approximating the left and right limits and comparing

LeftLimit

      LeftLimit (f,x0)

  Calculate the left limit of a real-valued function at x0

Limit

      Limit (f,x0)

  Calculate the limit of a real-valued function at x0. Tries to calculate both left and right limits.

MidpointRule

      MidpointRule (f,a,b,n)

  Integration by midpoint rule

NumericalDerivative

      NumericalDerivative (f,x0)

  Aliases: `NDerivative`

  Attempt to calculate numerical derivative

NumericalIntegral

      NumericalIntegral (f,a,b)

  Integration by rule set in NumericalIntegralFunction of f from a to b using NumericalIntegralSteps steps

NumericalLeftDerivative

      NumericalLeftDerivative (f,x0)

  Attempt to calculate numerical left derivative

NumericalLimitAtInfinity

      NumericalLimitAtInfinity (_f,step_fun,tolerance,successive_for_success,N)

  Attempt to calculate the limit of f(step_fun(i)) as i goes from 1 to N

NumericalRightDerivative

      NumericalRightDerivative (f,x0)

  Attempt to calculate numerical right derivative

OneSidedFivePointFormula

      OneSidedFivePointFormula (f,x0,h)

  Compute one-sided derivative using five point formula

OneSidedThreePointFormula

      OneSidedThreePointFormula (f,x0,h)

  Compute one-sided derivative using three-point formula

RightLimit

      RightLimit (f,x0)

  Calculate the right limit of a real-valued function at x0

TwoSidedFivePointFormula

      TwoSidedFivePointFormula (f,x0,h)

  Compute two-sided derivative using five-point formula

TwoSidedThreePointFormula

      TwoSidedThreePointFormula (f,x0,h)

  Compute two-sided derivative using three-point formula

# Functions

Argument

      Argument (z)

  Aliases: `Arg` `arg`

  argument (angle) of complex number

DirichletKernel

      DirichletKernel (n,t)

  Dirichlet kernel of order n

DiscreteDelta

      DiscreteDelta (v)

  Returns 1 iff all elements are zero

ErrorFunction

      ErrorFunction (x)

  Aliases: `erf`

  The error function, 2/sqrt(pi) * int_0^x e^(-t^2) dt

FejerKernel

      FejerKernel (n,t)

  Fejer kernel of order n

KroneckerDelta

      KroneckerDelta (v)

  Returns 1 iff all elements are equal

MinimizeFunction

      MinimizeFunction (func,x,incr)

  Find the first value where f(x)=0

MoebiusDiskMapping

      MoebiusDiskMapping (a,z)

  Moebius mapping of the disk to itself mapping a to 0

MoebiusMapping

      MoebiusMapping (z,z2,z3,z4)

  Moebius mapping using the cross ratio taking z2,z3,z4 to 1,0, and infinity respectively

MoebiusMappingInftyToInfty

      MoebiusMappingInftyToInfty (z,z2,z3)

  Moebius mapping using the cross ratio taking infinity to infinity and z2,z3 to 1 and 0 respectively

MoebiusMappingInftyToOne

      MoebiusMappingInftyToOne (z,z3,z4)

  Moebius mapping using the cross ratio taking infinity to 1 and z3,z4 to 0 and infinity respectively

MoebiusMappingInftyToZero

      MoebiusMappingInftyToZero (z,z2,z4)

  Moebius mapping using the cross ratio taking infinity to 0 and z2,z4 to 1 and infinity respectively

PoissonKernel

      PoissonKernel (r,sigma)

  Poisson kernel on D(0,1) (not normalized to 1, that is integral of this is 2pi)

PoissonKernelRadius

      PoissonKernelRadius (r,sigma)

  Poisson kernel on D(0,R) (not normalized to 1)

UnitStep

      UnitStep (x)

  The unit step function is 0 for x<0, 1 otherwise. This is the integral of the Dirac Delta function.

cis

      cis (x)

  The `cis` function, that is the same as `cos(x)+1i*sin(x)`

deg2rad

      deg2rad (x)

  Convert degrees to radians

rad2deg

      rad2deg (x)

  Convert radians to degrees

# Equation Solving

EulerMethod

      EulerMethod (f,x0,y0,x1,n)

  Use classical Euler's method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns `y` at `x1`.

  See Mathworld for more information.

FindRootBisection

      FindRootBisection (f,a,b,TOL,N)

  Find root of a function using the bisection method

FindRootFalsePosition

      FindRootFalsePosition (f,a,b,TOL,N)

  Find root of a function using the method of false position

FindRootMullersMethod

      FindRootMullersMethod (f,x1,x2,x3,TOL,N)

  Find root of a function using the Muller's method

FindRootSecant

      FindRootSecant (f,a,b,TOL,N)

  Find root of a function using the secant method

RungeKutta

      RungeKutta (f,x0,y0,x1,n)

  Use classical non-adaptive Runge-Kutta method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns `y` at `x1`.

  See Mathworld for more information.

# Statistics

Average

      Average (m)

  Aliases: `average` `Mean` `mean`

  Calculate average of an entire matrix

  See Mathworld for more information.

GaussDistribution

      GaussDistribution (x,sigma)

  Integral of the GaussFunction from 0 to x (area under the normal curve)

  See Mathworld for more information.

GaussFunction

      GaussFunction (x,sigma)

  The normalized Gauss distribution function (the normal curve)

  See Mathworld for more information.

Median

      Median (m)

  Aliases: `median`

  Calculate median of an entire matrix

  See Mathworld for more information.

PopulationStandardDeviation

      PopulationStandardDeviation (m)

  Aliases: `stdevp`

  Calculate the population standard deviation of a whole matrix

RowAverage

      RowAverage (m)

  Aliases: `RowMean`

  Calculate average of each row in a matrix

  See Mathworld for more information.

RowMedian

      RowMedian (m)

  Calculate median of each row in a matrix and return a column vector of the medians.

  See Mathworld for more information.

RowPopulationStandardDeviation

      RowPopulationStandardDeviation (m)

  Aliases: `rowstdevp`

  Calculate the population standard deviations of rows of a matrix and return a vertical vector

RowStandardDeviation

      RowStandardDeviation (m)

  Aliases: `rowstdev`

  Calculate the standard deviations of rows of a matrix and return a vertical vector

StandardDeviation

      StandardDeviation (m)

  Aliases: `stdev`

  Calculate the standard deviation of a whole matrix

# Polynomials

AddPoly

      AddPoly (p1,p2)

  Add two polynomials (vectors)

IsPoly

      IsPoly (p)

  Check if a vector is usable as a polynomial

MultiplyPoly

      MultiplyPoly (p1,p2)

  Multiply two polynomials (as vectors)

Poly2ndDerivative

      Poly2ndDerivative (p)

  Take second polynomial (as vector) derivative

PolyDerivative

      PolyDerivative (p)

  Take polynomial (as vector) derivative

PolyToFunction

      PolyToFunction (p)

  Make function out of a polynomial (as vector)

PolyToString

      PolyToString (p,var...)

  Make string out of a polynomial (as vector)

SubtractPoly

      SubtractPoly (p1,p2)

  Subtract two polynomials (as vectors)

TrimPoly

      TrimPoly (p)

  Trim zeros from a polynomial (as vector)

# Set Theory

Intersection

      Intersection (X,Y)

  Returns a set theoretic intersection of X and Y (X and Y are vectors pretending to be sets)

IsIn

      IsIn (x,X)

  Returns true if the element x is in the set X (where X is a vector pretending to be a set)

MakeSet

      MakeSet (X)

  Returns a set where every element of X appears only once

SetMinus

      SetMinus (X,Y)

  Returns a set theoretic difference X-Y (X and Y are vectors pretending to be sets)

Union

      Union (X,Y)

  Returns a set theoretic union of X and Y (X and Y are vectors pretending to be sets)

# Miscellaneous

ASCIIToString

      ASCIIToString (vec)

  Convert a vector of ASCII values to a string

AlphabetToString

      AlphabetToString (vec,alphabet)

  Convert a vector of 0-based alphabet values (positions in the alphabet string) to a string

StringToASCII

      StringToASCII (str)

  Convert a string to a vector of ASCII values

StringToAlphabet

      StringToAlphabet (str,alphabet)

  Convert a string to a vector of 0-based alphabet values (positions in the alphabet string), -1's for unknown letters