Man Linux: Main Page and Category List


       ginsh - GiNaC Interactive Shell


       ginsh [file...]


       ginsh  is  an  interactive  frontend for the GiNaC symbolic computation
       framework.  It is intended as a tool for testing and experimenting with
       GiNaC’s  features,  not  as  a  replacement for traditional interactive
       computer  algebra  systems.  Although  it  can  do  many  things  these
       traditional  systems  can  do, ginsh provides no programming constructs
       like loops or conditional expressions. If you need  this  functionality
       you  are advised to write your program in C++, using the "native" GiNaC
       class framework.


       After startup, ginsh displays a prompt ("> ")  signifying  that  it  is
       ready  to  accept  your input. Acceptable input are numeric or symbolic
       expressions consisting of numbers (e.g.   42,  2/3  or  0.17),  symbols
       (e.g.   x  or  result),  mathematical  operators  like  +  and   *, and
       functions (e.g.  sin  or  normal).   Every  input  expression  must  be
       terminated  with  either a semicolon (;) or a colon (:).  If terminated
       with a semicolon, ginsh will evaluate  the  expression  and  print  the
       result  to stdout. If terminated with a colon, ginsh will only evaluate
       the expression but not print  the  result.  It  is  possible  to  enter
       multiple  expressions  on one line. Whitespace (spaces, tabs, newlines)
       can be applied freely between tokens. To  quit  ginsh,  enter  quit  or
       exit, or type an EOF (Ctrl-D) at the prompt.

       Anything  following  a double slash (//) up to the end of the line, and
       all lines starting with a hash mark (#) are treated as  a  comment  and

       ginsh  accepts  numbers  in  the usual decimal notations. This includes
       arbitrary precision integers and rationals as well  as  floating  point
       numbers  in standard or scientific notation (e.g.  1.2E6).  The general
       rule is that if a number  contains  a  decimal  point  (.),  it  is  an
       (inexact)  floating point number; otherwise it is an (exact) integer or
       rational.  Integers can be specified in binary, octal,  hexadecimal  or
       arbitrary  (2-36)  base  by  prefixing  them  with #b, #o, #x, or #nR ,

       Symbols are made up of a string  of  alphanumeric  characters  and  the
       underscore (_), with the first character being non-numeric. E.g.  a and
       mu_1 are acceptable symbol names, while 2pi is not. It is  possible  to
       use symbols with the same names as functions (e.g.  sin); ginsh is able
       to distinguish between the two.

       Symbols can be assigned values by entering
              symbol = expression;

       To unassign the value of an assigned symbol, type

       Assigned symbols are  automatically  evaluated  (=  replaced  by  their
       assigned value) when they are used. To refer to the unevaluated symbol,
       put single  quotes  (’)  around  the  name,  as  demonstrated  for  the
       "unassign" command above.

       Symbols  are  considered  to  be in the complex domain by default, i.e.
       they are treated as if they stand in for complex numbers. This behavior
       can  be  changed by using the keywords real_symbols and complex_symbols
       and affects all newly created symbols.

       The following symbols are pre-defined constants that cannot be assigned
       a value by the user:

              Pi      Archimedes’ Constant

              Catalan Catalan’s Constant

              Euler   Euler-Mascheroni Constant

              I       sqrt(-1)

              FAIL    an object of the GiNaC "fail" class

       There is also the special
       symbol that controls the numeric precision of calculations with inexact
       numbers.   Assigning  an  integer  value  to  digits  will  change  the
       precision to the given number of decimal places.

       The  has(),  find(),  match()  and subs() functions accept wildcards as
       placeholders for expressions. These have the syntax
       for example $0, $1 etc.

       ginsh provides the three special symbols
              %, %% and %%%
       that refer to the last, second last, and third last printed expression,
       respectively.   These  are  handy  if  you  want  to use the results of
       previous computations in a new expression.

       ginsh provides the following operators,  listed  in  falling  order  of

              !       postfix factorial

              ^       powering

              +       unary plus

              -       unary minus

              *       multiplication

              /       division

              +       addition

              -       subtraction

              <       less than

              >       greater than

              <=      less or equal

              >=      greater or equal

              ==      equal

              !=      not equal

              =       symbol assignment

       All  binary operators are left-associative, with the exception of ^ and
       = which are right-associative. The result of  the  assignment  operator
       (=) is its right-hand side, so it’s possible to assign multiple symbols
       in one expression (e.g.  a = b = c = 2;).

       Lists are used by the subs and lsolve functions. A list consists of  an
       opening curly brace ({), a (possibly empty) comma-separated sequence of
       expressions, and a closing curly brace (}).

       A matrix consists of an opening square bracket ([), a non-empty  comma-
       separated  sequence  of  matrix rows, and a closing square bracket (]).
       Each matrix row consists of an opening square bracket ([), a  non-empty
       comma-separated  sequence  of expressions, and a closing square bracket
       (]).  If the rows of a matrix are not of the same length, the width  of
       the  matrix becomes that of the longest row and shorter rows are filled
       up at the end with elements of value zero.

       A function call in ginsh has the form
       where arguments is a comma-separated  sequence  of  expressions.  ginsh
       provides a couple of built-in functions and also "imports" all symbolic
       functions defined by GiNaC and additional libraries. There is no way to
       define  your  own  functions other than linking ginsh against a library
       that defines symbolic GiNaC functions.

       ginsh provides Tab-completion on function names: if you type the  first
       part  of  a  function  name,  hitting  Tab  will  complete  the name if
       possible. If the part you typed is not unique, hitting Tab  again  will
       display  a list of matching functions.  Hitting Tab twice at the prompt
       will display the list of all available functions.

       A list of the built-in functions follows. They nearly all work  as  the
       respective  GiNaC methods of the same name, so I will not describe them
       in detail here. Please refer to the GiNaC documentation.

              charpoly(matrix, symbol) - characteristic polynomial of a matrix
              coeff(expression,  object,  number)  -  extracts  coefficient of
              object^number from a polynomial
              collect(expression, object-or-list) - collects  coefficients  of
              like powers (result in recursive form)
              collect_distributed(expression, list) - collects coefficients of
              like powers (result in distributed form)
              collect_common_factors(expression)  -  collects  common  factors
              from the terms of sums
              conjugate(expression) - complex conjugation
              content(expression, symbol) - content part of a polynomial
              decomp_rational(expression,   symbol)   -   decompose   rational
              function into polynomial and proper rational function
              degree(expression, object) - degree of a polynomial
              denom(expression) - denominator of a rational function
              determinant(matrix) - determinant of a matrix
              diag(expression...)  - constructs diagonal matrix
              diff(expression, symbol [, number]) - partial differentiation
              divide(expression, expression) - exact polynomial division
              eval(expression [, level]) - evaluates an expression,  replacing
              symbols by their assigned value
              evalf(expression  [,  level])  -  evaluates  an  expression to a
              floating point number
              evalm(expression) - evaluates sums, products and integer  powers
              of matrices
              expand(expression) - expands an expression
              factor(expression) - factorizes an expression (univariate)
              find(expression, pattern) - returns a list of all occurrences of
              a pattern in an expression
              fsolve(expression, symbol, number, number)  -  numerically  find
              root of a real-valued function within an interval
              gcd(expression, expression) - greatest common divisor
              has(expression,  pattern)  - returns "1" if the first expression
              contains the pattern as a subexpression, "0" otherwise
              integer_content(expression) - integer content of a polynomial
              inverse(matrix) - inverse of a matrix
              is(relation)  -  returns  "1"  if  the  relation  is  true,  "0"
              otherwise (false or undecided)
              lcm(expression, expression) - least common multiple
              lcoeff(expression, object) - leading coefficient of a polynomial
              ldegree(expression, object) - low degree of a polynomial
              lsolve(equation-list, symbol-list)  -  solve  system  of  linear
              map(expression,  pattern)  - apply function to each operand; the
              function to be applied is specified as a pattern with  the  "$0"
              wildcard standing for the operands
              match(expression,  pattern) - check whether expression matches a
              pattern; returns a list of wildcard substitutions or  "FAIL"  if
              there is no match
              nops(expression) - number of operands in expression
              normal(expression [, level]) - rational function normalization
              numer(expression) - numerator of a rational function
              numer_denom(expression)   -   numerator  and  denumerator  of  a
              rational function as a list
              op(expression, number) - extract operand from expression
              power(expr1, expr2)  -  exponentiation  (equivalent  to  writing
              prem(expression,   expression,  symbol)  -  pseudo-remainder  of
              primpart(expression, symbol) - primitive part of a polynomial
              quo(expression, expression, symbol) - quotient of polynomials
              rank(matrix) - rank of a matrix
              rem(expression, expression, symbol) - remainder of polynomials
              resultant(expression, expression, symbol)  -  resultant  of  two
              polynomials with respect to symbol s
              series(expression, relation-or-symbol, order) - series expansion
              sprem(expression, expression, symbol) - sparse  pseudo-remainder
              of polynomials
              sqrfree(expression  [, symbol-list]) - square-free factorization
              of a polynomial
              sqrt(expression) - square root
              subs(expression, relation-or-list)
              subs(expression, look-for-list,  replace-by-list)  -  substitute
              subexpressions (you may use wildcards)
              tcoeff(expression,   object)   -   trailing   coefficient  of  a
              time(expression)  -  returns  the  time  in  seconds  needed  to
              evaluate the given expression
              trace(matrix) - trace of a matrix
              transpose(matrix) - transpose of a matrix
              unassign(symbol)  -  unassign  an  assigned  symbol  (mind the
              quotes, please!)
              unit(expression, symbol) - unit part of a polynomial

       To exit ginsh, enter

       ginsh can display a (short)  help  for  a  given  topic  (mostly  about
       functions and operators) by entering
       will display a list of available help topics.

       The command
       will  print  a  dump  of  GiNaC’s internal representation for the given
       expression.  This is useful for debugging and for learning about  GiNaC

       The command
       prints a LaTeX representation of the given expression.

       The command
       prints  the  given  expression  in a way that can be used in a C or C++

       The command
       prints the given expression (which must  evaluate  to  an  integer)  in
       decimal, octal, and hexadecimal representations.

       Finally, the shell escape
              !  [command  [arguments]]
       passes  the  given  command  and  optionally arguments to the shell for
       execution. With this method, you can execute shell commands from within
       ginsh without having to quit.


       > a = x^2-x-2;
       > b = (x+1)^2;
       > s = a/b;
       > diff(s, x);
       > normal(s);
       > x = 3^50;
       > s;
       > Digits = 40;
       > evalf(s);
       > unassign(’x’);
       > s;
       > series(sin(x),x==0,6);
       > lsolve({3*x+5*y == 7}, {x, y});
       > lsolve({3*x+5*y == 7, -2*x+10*y == -5}, {x, y});
       > M = [ [a, b], [c, d] ];
       > determinant(M);
       > collect(%, x);
       > solve quantum field theory;
       parse error at quantum
       > quit


       parse error at foo
              You  entered  something  which ginsh was unable to parse. Please
              check the syntax of your input and try again.

       argument num to function must be a type
              The argument number num to the  given  function  must  be  of  a
              certain  type (e.g. a symbol, or a list). The first argument has
              number 0, the second argument number 1, etc.


       The GiNaC Group:
              Christian Bauer <>
              Alexander Frink <>
              Richard Kreckel <>
              Jens Vollinga <>


       GiNaC Tutorial - An open framework for symbolic computation within  the
       C++ programming language

       CLN - A Class Library for Numbers, Bruno Haible


       Copyright © 1999-2010 Johannes Gutenberg Universität Mainz, Germany

       This program is free software; you can redistribute it and/or modify it
       under the terms of the GNU General Public License as published  by  the
       Free  Software Foundation; either version 2 of the License, or (at your
       option) any later version.

       This program is distributed in the hope that it  will  be  useful,  but
       WITHOUT   ANY   WARRANTY;   without   even   the  implied  warranty  of
       General Public License for more details.

       You should have received a copy of the GNU General Public License along
       with this program; if not, write to the Free Software Foundation, Inc.,
       675 Mass Ave, Cambridge, MA 02139, USA.