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 and return a function that is the composition of f and g.

ComposePower

      ComposePower (f,n,x)

  Compose a function with itself n times, passing x as argument, and returning x if n == 0. Examples:

      genius> function f(x) = x^2 ;
      genius> ComposePower (f,3,7)
      = 5764801
      genius> f(f(f(7)))
      = 5764801

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

IsFunctionOrIdentifier

      IsFunctionOrIdentifier (arg)

  Check if argument is a function or identifier

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

wait

      wait (secs)

  Waits a specified number of seconds.

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

LinePlotWindow

      LinePlotWindow = [x1,x2,y1,y2]

  Sets the limits for line plotting (See LinePlot).

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

SurfacePlotWindow

      SurfacePlotWindow = [x1,x2,y1,y2,z1,z2]

  Sets the limits for surface plotting (See SurfacePlot).

# Constants

CatalanConstant

      CatalanConstant

  Catalan's Constant, approximately 0.915... It is defined to be the series where terms are `(-1^k)/((2*k+1)^2)`, where k ranges from 0 to infinity.

  See Mathworld for more information.

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 Planetmath (absolute value), Planetmath (modulus), Mathworld (absolute value) or Mathworld (complex modulus) 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 (inverse cos) function

acosh

      acosh (x)

  Aliases: `arccosh`

  The arccosh (inverse cosh) function

acot

      acot (x)

  Aliases: `arccot`

  The arccot (inverse cot) function

acoth

      acoth (x)

  Aliases: `arccoth`

  The arccoth (inverse coth) function

acsc

      acsc (x)

  Aliases: `arccsc`

  The inverse cosecant function

acsch

      acsch (x)

  Aliases: `arccsch`

  The inverse hyperbolic cosecant function

asec

      asec (x)

  Aliases: `arcsec`

  The inverse secant function

asech

      asech (x)

  Aliases: `arcsech`

  The inverse hyperbolic secant function

asin

      asin (x)

  Aliases: `arcsin`

  The arcsin (inverse sin) function

asinh

      asinh (x)

  Aliases: `arcsinh`

  The arcsinh (inverse sinh) function

atan

      atan (x)

  Aliases: `arctan`

  Calculates the arctan (inverse tan) function.

  See Mathworld for more information.

atanh

      atanh (x)

  Aliases: `arctanh`

  The arctanh (inverse tanh) function

atan2

      atan2 (y, x)

  Aliases: `arctan2`

  Calculates the arctan2 function. If `x>0` then it returns `atan(y/x)`. If `x<0` then it returns `sign(y) * (pi - atan(|y/x|)`. When `x=0` it returns `sign(y) * pi/2`. `atan2(0,0)` returns 0 rather then failing.

  See Mathworld for more information.

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 Planetmath or 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 Planetmath or 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 Planetmath or 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 Planetmath or Mathworld for more information.

LucasLehmer

      LucasLehmer (p)

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

  See Planetmath or Mathworld for more information.

LucasNumber

      LucasNumber (n)

  Returns the n'th Lucas number

  See Planetmath or 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 Planetmath or 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 Planetmath or Mathworld for more information.

ModInvert

      ModInvert (n,m)

  Returns inverse of n mod m

  See Mathworld for more information.

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 Planetmath or 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 (See also MillerRabinTest). The probability of false positive is not tunable, but is low enough for all practical purposes.

  See Planetmath or Mathworld for more information.

PadicValuation

      PadicValuation (n,p)

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

  See Planetmath for more information.

PowerMod

      PowerMod (a,b,m)

  Compute `a^b mod m`. The `b`'s power of `a` modulo `m`.

Prime

      Prime (n)

  Aliases: `prime`

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

  See Planetmath or Mathworld for more information.

PrimeFactors

      PrimeFactors (n)

  Return all prime factors of a number as a vector.

  See Mathworld for more information.

PseudoprimeTest

      PseudoprimeTest (n,b)

  Pseudoprime test, returns true if and only if `b^(n-1) == 1 mod n`

  See Planetmath or Mathworld for more information.

RemoveFactor

      RemoveFactor (n,m)

  Removes all instances of the factor `m` from the number `n`. That is divides by the largest power of `m`, that divides `n`.

  See Planetmath or Mathworld for more information.

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` modulo `p` (where `p` is a prime). Null is returned if not a quadratic residue.

  See Planetmath or Mathworld for more information.

StrongPseudoprimeTest

      StrongPseudoprimeTest (n,b)

  Run the strong pseudoprime test base `b` on `n`.

  See Planetmath or Mathworld for more information.

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 Planetmath or 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 Planetmath or 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

CountZeroColumns

      CountZeroColumns (M)

  Count the number of zero columns in a matrix. For example Once you column reduce a matrix you can use this to find the nullity. See cref and Nullity.

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)

  Get the dot product of two vectors. The vectors must be of the same size. No conjugates are taken so this is a bilinear form even if working over the complex numbers.

  See Planetmath for more information.

ExpandMatrix

      ExpandMatrix (M)

  Expands a matrix just like we do on unquoted matrix input. That is we expand any internal matrices as blocks. This is a way to construct matrices out of smaller ones and this is normally done automatically on input unless the matrix is quoted.

HermitianProduct

      HermitianProduct (u,v)

  Aliases: `InnerProduct`

  Get the hermitian product of two vectors. The vectors must be of the same size. This is a sesquilinear form using the identity matrix.

  See Mathworld for more information.

I

      I (n)

  Aliases: `eye`

  Return an identity matrix of a given size, that is `n` by `n`.

  See Planetmath for more information.

IndexComplement

      IndexComplement (vec,msize)

  Return the index complement of a vector of indexes

IsDiagonal

      IsDiagonal (M)

  Is a matrix diagonal

  See Planetmath for more information.

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)

  Check if a matrix is square, that is its width is equal to its height.

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. Genius does not distinguish between a matrix and a vector and a vector is just a 1 by n or n by 1 matrix.

LowerTriangular

      LowerTriangular (M)

  Zero out entries above the diagonal

MakeDiagonal

      MakeDiagonal (v,arg...)

  Aliases: `diag`

  Make diagonal matrix from a vector

  See Planetmath for more information.

MakeVector

      MakeDiagonal (A)

  Make column vector out of matrix by putting columns above each other. Returns null when given null.

MatrixProduct

      MatrixProduct (a)

  Calculate the product of all elements in a matrix. That is we multiply all the elements and return a number that is the product of all the elements.

MatrixSum

      MatrixSum (a)

  Calculate the sum of all elements in a matrix. That is we add all the elements and return a number that is the sum of all the elements.

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. That is, a new matrix will be returned to which the old one is copied. Entries that don't fit are clipped and extra space is filled with zeros.

SortVector

      SortVector (v)

  Sort vector elements in an increasing order.

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

CommutationMatrix

      CommutationMatrix (m, n)

  Return the commutation matrix K(m,n) which is the unique m*n by m*n matrix such that K(m,n) * MakeVector(A) = MakeVector(A.') for all m by n matrices A.

CompanionMatrix

      CompanionMatrix (p)

  Companion matrix of a polynomial (as vector)

ConjugateTranspose

      ConjugateTranspose (M)

  Conjugate transpose of a matrix (adjoint). This is the same as the `'` operator.

  See Planetmath for more information.

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 inner product given by `B`. If `B` is not given then the standard hermitian product is used. `B` can either be a sesquilinear function of two arguments or it can be a matrix giving a sesquilinear form. The vectors will be made orthonormal with respect to `B`.

  See Planetmath for more information.

HankelMatrix

      HankelMatrix (c,r)

  Hankel matrix

HilbertMatrix

      HilbertMatrix (n)

  Hilbert matrix of order `n`.

  See Planetmath for more information.

Image

      Image (T)

  Get the image (columnspace) of a linear transform

InfNorm

      InfNorm (v)

  Get the Inf Norm of a vector, sometimes called the sup norm or the max norm.

InvariantFactorsInteger

      InvariantFactorsInteger (M)

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

InverseHilbertMatrix

      InverseHilbertMatrix (n)

  Inverse Hilbert matrix of order `n`.

  See Planetmath for more information.

IsHermitian

      IsHermitian (M)

  Is a matrix hermitian. That is, is it equal to its conjugate transpose.

  See Planetmath for more information.

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. That is, is the conjugate transpose equal to negative of the matrix.

  See Planetmath for more information.

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.

  (See NullSpace)

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 true if successful. 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 Planetmath or Mathworld for more information.

Minor

      Minor (M,i,j)

  Get the `i`-`j` minor of a matrix.

  See Planetmath for more information.

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. That is the kernel of the linear mapping that the matrix represents. This is returned as a matrix whose column space is the nullspace of `T`.

  See Planetmath for more information.

Nullity

      Nullity (M)

  Aliases: `nullity`

  Get the nullity of a matrix.

  See Planetmath for more information.

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` with respect to inner product given by `B`. If `B` is not given then the standard hermitian product is used. `B` can either be a sesquilinear function of two arguments or it can be a matrix giving a sesquilinear form.

QRDecomposition

      QRDecomposition (A, Q)

  Get the QR decomposition of a square matrix `A`, returns the upper triangular matrix `R` and sets `Q` to the orthogonal (unitary) matrix. `Q` should be a reference or null if you don't want any return. For example:

      genius> R = QRDecomposition(A,&Q)

  You will have the upper triangular matrix stored in a variable called `R` and the orthogonal (unitary) matrix stored in `Q`.

  See Planetmath or Mathworld for more information.

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.

  See Planetmath for more information.

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

SesquilinearForm

      SesquilinearForm (v,A,w)

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

SesquilinearFormFunction

      SesquilinearFormFunction (A)

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

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.

ToeplitzMatrix

      ToeplitzMatrix (c, r...)

  Return the Toeplitz matrix constructed given the first column c and (optionally) the first row r. If only the column c is given then it is conjugated and the nonconjugated version is used for the first row to give a Hermitian matrix (if the first element is real of course).

  See Planetmath for more information.

Trace

      Trace (m)

  Aliases: `trace`

  Calculate the trace of a matrix

Transpose

      Transpose (M)

  Transpose of a matrix. This is the same as the `.'` operator.

  See Planetmath for more information.

VandermondeMatrix

      VandermondeMatrix (v)

  Aliases: `vander`

  Return the Vandermonde matrix

VectorAngle

      VectorAngle (v,w,B...)

  The angle of two vectors with respect to inner product given by `B`. If `B` is not given then the standard hermitian product is used. `B` can either be a sesquilinear function of two arguments or it can be a matrix giving a sesquilinear form.

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.

  See Planetmath for more information.

ref

      ref (M)

  Aliases: `REF` `RowEchelonForm`

  Get the row echelon form of a matrix.

  See Planetmath for more information.

rref

      rref (M)

  Aliases: `RREF` `ReducedRowEchelonForm`

  Get the reduced row echelon form of a matrix.

  See Planetmath for more information.

# Combinatorics

Catalan

      Catalan (n)

  Get `n`'th catalan number.

  See Planetmath for more information.

Combinations

      Combinations (k,n)

  Get all combinations of k numbers from 1 to n as a vector of vectors. (See also NextCombination)

DoubleFactorial

      DoubleFactorial (n)

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

  See Planetmath for more information.

Factorial

      Factorial (n)

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

  See Planetmath for more information.

FallingFactorial

      FallingFactorial (n,k)

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

  See Planetmath for more information.

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 Planetmath or 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 `n`'th 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

NextCombination

      NextCombination (v,n)

  Get combination that would come after v in call to combinations, first combination should be `[1:k]`. This function is useful if you have many combinations to go through and you don't want to waste memory to store them all.

  For example with Combination you would normally write a loop like:

      for n in Combinations (4,6) do (
        SomeFunction (n)
      );

  But with NextCombination you would write something like:

      n:=[1:4];
      do (
        SomeFunction (n)
      ) while not IsNull(n:=NextCombination(n,6));

  See also Combinations.
Pascal

      Pascal (i)

  Get the Pascal's triangle as a matrix. This will return an `i`+1 by `i`+1 lower diagonal matrix which is the Pascal's triangle after `i` iterations.

  See Planetmath for more information.

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))

  See Planetmath for more information.

Subfactorial

      Subfactorial (n)

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

Triangular

      Triangular (nth)

  Calculate the `n`'th triangular number.

  See Planetmath for more information.

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.

  See Planetmath for more information.

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.

  See Planetmath for more information.

Derivative

      Derivative (f,x0)

  Attempt to calculate derivative by trying first symbolically and then numerically.

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

  See Planetmath for more information.

FejerKernel

      FejerKernel (n,t)

  Fejer kernel of order `n` evaluated at `t`

  See Planetmath for more information.

GammaFunction

      GammaFunction (x)

  Aliases: `Gamma`

  The Gamma function. Currently only implemented for real values.

  See Planetmath for more information.

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

  See Planetmath for more information.

MoebiusMapping

      MoebiusMapping (z,z2,z3,z4)

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

  See Planetmath for more information.

MoebiusMappingInftyToInfty

      MoebiusMappingInftyToInfty (z,z2,z3)

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

  See Planetmath for more information.

MoebiusMappingInftyToOne

      MoebiusMappingInftyToOne (z,z3,z4)

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

  See Planetmath for more information.

MoebiusMappingInftyToZero

      MoebiusMappingInftyToZero (z,z2,z4)

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

  See Planetmath for more information.

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)

RiemannZeta

      RiemannZeta (x)

  Aliases: `zeta`

  The Riemann zeta function. Currently only implemented for real values.

  See Planetmath for more information.

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

CubicFormula

      CubicFormula (p)

  Compute roots of a cubic (degree 3) polynomial using the cubic formula. The polynomial should be given as a vector of coefficients. That is `4*x^3 + 2*x + 1` corresponds to the vector `[1,2,0,4]`.

  Note that due to limitations of the current implementation, only polynomials with real coefficients are supported.

  See Planetmath or Mathworld for more information.

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

PolynomialRoots

      PolynomialRoots (p)

  Compute roots of a polynomial (degrees 1 through 3 currently) using one of the formulas for such polynomials. The polynomial should be given as a vector of coefficients. That is `4*x^3 + 2*x + 1` corresponds to the vector `[1,2,0,4]`.

  The function calls QuadraticFormula and CubicFormula.

QuadraticFormula

      QuadraticFormula (p)

  Compute roots of a quadratic (degree 2) polynomial using the quadratic formula. The polynomial should be given as a vector of coefficients. That is `3*x^2 + 2*x + 1` corresponds to the vector `[1,2,3]`.

  See Planetmath or Mathworld for more information.

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)

NewtonsMethodPoly

      NewtonsMethodPoly (poly,guess,epsilon,maxn)

  Run newton's method on a polynomial to attempt to find a root, returns after two successive values are within epsilon or after maxn tries (then returns null).

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

# Symbolic Operations

SymbolicDerivative

      SymbolicDerivative (f)

  Attempt to symbolically differentiate the function f, where f is a function of one variable.

  Examples:

      genius> SymbolicDerivative(sin)
      genius> (`(x)=cos(x))
      genius> SymbolicDerivative(`(x)=7*x^2)
      genius> (`(x)=(7*(2*x)))

SymbolicDerivativeTry

      SymbolicDerivativeTry (f)

  Attempt to symbolically differentiate the function f, where f is a function of one variable, returns null if unsuccessful but is silent. (See SymbolicDerivative)

SymbolicNthDerivative

      SymbolicNthDerivative (f,n)

  Attempt to symbolically differentiate a function n times. (See SymbolicDerivative)

SymbolicNthDerivativeTry

      SymbolicNthDerivativeTry (f,n)

  Attempt to symbolically differentiate a function n times quietly and return null on failure (See SymbolicNthDerivative)

SymbolicTaylorApproximationFunction

      SymbolicTaylorApproximationFunction (f,x0,n)

  Attempt to construct the taylor approximation function around x0 to the nth degree. (See SymbolicDerivative)

# Plotting

LinePlot

      LinePlot (func1,func2,func3,...)

      LinePlot (func1,func2,func3,x1,x2,y1,y2)

  Plot a function (or several functions) with a line. First up to 10 arguments are functions, then optionally you can specify the limits of the plotting window as `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See LinePlotWindow)

  Examples:

      genius> LinePlot(sin,cos)
      genius> LinePlot(`(x)=x^2,-1,1,0,1)

LinePlotClear

      LinePlotClear ()

  Show the line plot window and clear out functions and any other lines that were drawn.

LinePlotDrawLine

      LinePlotDrawLine (x1,y1,x2,y2,...)

      LinePlotDrawLine (v,...)

  Draw a line from `x1`,`y1` to `x2`,`y2`. `x1`,`y1`, `x2`,`y2` can be replaced by an `n` by 2 matrix for a longer line.

  Extra parameters can be added to specify line color and thickness, by adding a string `"color"` or `"thickness"` and the color and thickness after as a string or integer respectively.

  Examples:

      genius> LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)
      genius> LinePlotDrawLine([0,0;1,-1;-1,-1])

LinePlotParametric

      LinePlotParametric (xfunc,yfunc,...)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc,x1,x2,y1,y2)

  Plot a parametric function with a line. First come the functions for x and y then optionally the t limits as t1,t2,tinc, then optionally the limits as x1,x2,y1,y2.

LinePlotCParametric

      LinePlotCParametric (func,...)

      LinePlotCParametric (func,t1,t2,tinc)

      LinePlotCParametric (func,t1,t2,tinc,x1,x2,y1,y2)

  Plot a parametric complex valued function with a line. First comes the function that returns x+iy then optionally the t limits as t1,t2,tinc, then optionally the limits as x1,x2,y1,y2.

SurfacePlot

      SurfacePlot (func)

      SurfacePlot (func,x1,x2,y1,y2,z1,z2)

  Plot a surface function which takes either two arguments or a complex number. First comes the function then optionally limits as `x1`, `x2`, `y1`, `y2`, `z1`, `z2`. If limits are not specified, then the currently set limits apply (See SurfacePlotWindow). Genius can only plot a single surface function at this time.

  Examples:

      genius> SurfacePlot(|sin|,-1,1,-1,1,0,1.5)
      genius> SurfacePlot(`(x,y)=x^2+y,-1,1,-1,1,-2,2)
      genius> SurfacePlot(`(z)=|z|^2,-1,1,-1,1,0,2)