8.1        Keywords in Topic Order
---------------------------------------------------------------------
Arithmetic operators: 
        +, -, *, /      plus, minus, times, division
        ^, **           power
        ()

Relational operators: 
        ==              equals
        >               greater than
        >=              greater than or equal
        <               less than
        <=              less than or equal
        <>              not equal

Assignments: 
        :=              

Equation:
  = 
  solve(x^2=1,x)                  solve x^2=1 for x               
  solve([x+y=b,x-y=c], [x,y])     solve  x+y=b and x-y=c for x and y
  psolve(f(x),x)                  solve f(x)=0 for x
  lsolve(f(x,y),g(x,y), x,y)      solve f(x,y)=0 and g(x,y)=0 for x and y
  nsolve(cos(x)=x,x)              numerically solve f(x)=0 for x with initial x0=1
  nsolve(f(x)=0,x,x0)             numerically solve f(x)=0 for x with initial x0
  dsolve(y'(x)=f(x,y), y(x),x)    solve differential eq y'=f(x,y) for y(x)

Comment: 
        #

Built-in constants: 
        i, e, pi, inf, zero, constant, discont, c_inf, undefined.

Built-in variables: 
        last

Logic operators: 
        and, or, not(x)

Algebraic functions: 
        -x              minus x
        sqrt(x)         sqare root of x
        n!              factorial of n
        fac(n)          faction of n
        mod(x,y)        reminder on division of x by y
        div(x,y),       integer divide x by y
        random          random number 0<= x<1
        random(x)       random number <= x
        expand(x)       expand x
        factor(x)       factor x
        factor(poly,x)  factor poly in x
        root(x,n)       all n-th roots of x

Complex to real: 
        re(x)           real part of the complex number x
        im(x)           imaginative part of the complex number x
        abs(x)          absolute value of x
        |x|             absolute value of x
        arg(x)          argument of complex number x
        sign(x)         sign of complex number of x

Exponential functions: 
        exp(x)          natual expoential of x, exp(x)=e^x
        ln(x)           natual logarithm of x
        log10(x)        log of x to base 10

Trig functions: 
        sin(x)          sine of x
        cos(x)          cosine of x
        tan(x)          tangent of x
        csc(x)          cosecant of x
        sec(x)          secant of x
        cot(x)          cotangent of x

Inverse trig functions:
        asin(x)         angle whose sine is x
        acos(x)         angle whose cosine is x
        atan(x)         angle whose tangent is x
        acot(x)         angle whose cotangent is x
        asec(x)         angle whose secant is x
        acsc(x)         angle whose cosecant is x
        atan2(x,y)      angle whose tangent is x/y

Hyperbolic functions: 
        sinh(x)         hyperbolic sine of x
        cosh(x)         hyperbolic cosine of x
        tanh(x)         hyperbolic tangent of x
        csch(x)         hyperbolic cosecant of x
        sech(x)         hyperbolic secant of x
        coth(x)         hyperbolic cotangent of x

Inverse hyperbolic functions: 
        asinh(x)
        acosh(x)
        atanh(x)
        acoth(x)
        acsch(x)
        asech(x)

Special math integral functions: 
        ei(x)           expoential integral function
        ei(n,x)         incomplete exponential integral function inte(t^n*e^t, t,-inf,x)
        gamma(n)        gamma function inte(t^(n-1)*e(-t), t,0,inf)=(n-1)!
        gamma(n,x)      incomplete gamma function inte(t^n*e(-t), t,0,x)
        erf(x)          error function 2/sqrt(pi)*inte(e^(-t^2),t,0,x)
        si(x)           sine integral function inte(sin(x)/x)
        ci(x)           cosine integral function inte(cos(x)/x)
        li(x)           log integral function inte(1/ln(t), t,0,x)
        li(n,x)         incomplete log integral function inte(ln(t)^n, t,0,x)

Defining functions: 
        f(x_) := x^2
        f(x_) := if(x>0 then x^2)

Defining procedures: 
        f(x_) := block(p:=x^2,p,local(p))

Defining rules: 
        log(x_ * y_) := log(x)+log(y)
        f'(x_) := sin(x)

Clear:
        clear(x)                clear variable x
        clear(f(x))             clear function f(x)
        clear(a>0)              clear unequal a>0

Calculus functions: 
Differentiating: 
        d(y,x)          differentiate y with respect to x
        d(y,x,n)        differentiate y with respect to x in the n-th order
        diff(y,x=x0)    differentiate y with respect to x at x0
        diff(y,x=x0,n)  differentiate y with respect to x at x0 in the n-th order
        f'(x)           differentiate f(x) with respect to x
 
Integrating:      
  inte(y,x)               integrate y with respect to x
  inte(y,x,xmin,xmax)     integrate y with respect to x from xmin to xmax
  ninte(y,x,xmin,xmax)    numerically integrate y w.r.t. x from xmin to xmax

Substituting: 
        subs(y,x=x0)            substitute x by x0 in y

Limit:  
        lim(y,x=x0)             limit of y as x  -> x0
        lim(y,x=x0+zero)        limit of y as x  -> x0 from right
        lim(y,x=x0-zero)        limit of y as x  -> x0 from left
        nlim(y, x=x0)   numeric limit of y as x  -> x0

        laplace(y,x)            Laplace transform

        sum(y, x,xmin,xmax,dx)  sum of y w.r.t x from xmin to xmax step dx
        partsum(y,x)            partial sum of y
        infsum(y,x)             infinite sum of y

        prod(y, x,xmin,xmax,dx)  product of y w.r.t x from xmin to xmax step dx
        partprod(y,x)            partial product of y
        infprod(y,x)             infinite product of y

        series(y,x)             series of y at x=0 to order of 5
        series(y,x,x0)          series of y at x=x0 to order of 5
        series(y,x,x0,order)    series of y at x=x0 to order

Conversion functions:
        ratio(x)                convert real number to ratio
        round(x)                convert x to the rounded integer closet to x
        trunc(x)                convert x to the truncated integer closet to x
        nume(a/b)               numerator of a/b
        deno(a/b)               denominator of a/b
        number(x)               convert a string to a number
        string(x)               convert a number to a string
        term(a+b)               a list of terms
        multi(a*b)              a list of multipliers
        type(x)                 type of x

Table:
  table(x)                produce a table of the function values from x=-5 to 5 with step 1
  table(x,xmin,xmax)      produce a table of the function values from x=xmin to xmax on step 1
  table(x,xmin,xmax,dx)   produce a table of the function values from x=xmin to xmax                                      with step dx

Numeric computation: 
  num(x)                  numeric value of x
  nsolve(cos(x)=x,x)      numerically solve cos(x)=x w.r.t. x with initial x0=1
  nsolve(cos(x)=x,x,x0)   numerically solve cos(x)=x w.r.t. x with initial x0
  ninte(y,x,xmin,xmax)    numerically integrate y w.r.t. x from xmin to xmax
  nlim(y,x=x0)            numerica limit of y w.r.t. x at x0
  numeric:=on             numeric switch on

Test functions: 
        isodd(x)                test if x is odd
        iseven(x)               test if x is even
        isinteger(x)            test if x is integer
        isratio(x)              test if x is rational number
        isreal(x)               test if x is real
        iscomplex(x)            test if x is complex
        isnumber(x)             test if x is a number
        islist(x)               test if x is a list
        isfree(y,x)             test if y is free of x
        issame(x,y)             test if x is same as y
        islarger(a,b)           test if a is larger than b
        isless(a,b)             test if a is less than b
        type(x)=="real"         test if x is real

Polynomials:
  polydiv(a/b,x)        polynomials a/b
  polydiv2(a,b,x)       polynomials a/b
  polymod(a,b,x)        polynomial mod a/b
  factor(poly,x)        factor poly in x
  together(a/b+c/d)     together a/b+c/d to (a*d+c*b)/(b*d)

Number Theory:
  ifactor(n)      factor n
  prime(n)        n-th prime
  int(x)          integer part
  frac(x)         fractional part
  floor(x)
  ceiling(x)
  trunc(x)        truncate x
  round(x)        round x
  mod(x,y)        reminder on division of x by y
  div(x,y)        integer divide x by y
  gcd(a,b)        the greatest common divider of a and b

Vector or list: 
        [a,b]                   vector or list
        [list(y,x,xmin,xmax)]
        member([a],j)           the j-th member of a list [a]
        last[1]                 the first member of the last list
        reverse([x])            reverse a list x
        a[1]                    list index, the first member of a list a
        dottime(a,b)            dot product of vectors a and b
        
Matrix or array: 
        [[a11,a12],[a21,a22]]           matrix or array
        a[a[1]]

Statistics: 
  average([a,b])          avergae of a list of [a,b]
  max([a,b])              max of a list of [a,b]
  min([a,b])              min of a list of [a,b]
  listsum([a,b])          convert a list of [a,b] to sum a+b
  length([a,b])           length of a list of [a,b]
  std([a,b])              standard deviation
  var([a,b])              variant
  fit([x1,x2],[y1,y2])    fits data into a straight line a+b*x
  fitplot([x1,x2],[y1,y2],x)  fits and plots data into a straight line

Switches: 
        numeric
        output
        expand
        expandexp
        lowercase
        :=
        on
        off
        basic
        fortran
        prolog
        math

DOS Commands: 
        system("dir")

Comma: 
        , 
        from
        to
        step
        then
        else
        until

Assume: 
        assume(a>0)     assume a > 0
        isreal(x):=1    assume x is real

Conditional: 
        if(x>0 then x)                  if x > 0 then x
        if(x>0 then x else -x)          if x > 0 then x else -x

Loop: 
  repeat(expr until x>5)        repeat expr unti x>5
  do(expr, x,xmin,xmax,dx)      do expr w.r.t. x from xmin to xmax with step dx, last output
  list(y,x,xmin,xmax)           do expr w.r.t. x from xmin to xmax with step dx, all output

Reading: 
        readfile("file")        read a file with filename "file"
        readchar                read charactor
        readline                read a line

Writing: 
        openfile("file")        open a file named "file"
        closefile("file")       close a file named "file"
        writes(x)               write text or number on graph mode
        null
        newline                 write a new line

String: 
        "123"                   string
        concat("a","b")         concate "a" and "b"
        break("ab",1)           break "ab" from the first member
        length("a")             length of "a"
        string(1)               convert a number to a string

Getting parts: 
        type(x)         type of x
        left(a=b)       left side of a=b
        right(a=b)      right side of a=b
        term(a+b)               
        multi(a*b)
        coef(y,x)       coefficeint of x in y
        coef(y,x,n)     coefficeint of x with the n-th order in y
        coefall(y,x)    a list of all coefficients of x in y from low to high, order <5.
        power(x^n)      powe, give n
        base(x^n)       base, give x
        argue(x)        argument of function, argue(f(x)) gives x
        sequence(x)
        re(x)           real part
        im(x)           imaginative part
        int(x)          integer part
        frac(x)         fractional part
        floor(x)
        ceiling(x)

Database: 
        phoneno(x)              phone number
        colorno(x)              color number
        atom_wei(x)             atomic weight

Graph: 
  graph                   graph mode
  text                    text mode
  cleardevice             clear graph screen

  line(x1,y1,x2,y2)       draw a line from point (x1,y1) to (x2,y2)
  lineto(x,y)             draw a line from current point to (x,y)
  linerel(dx,dy)          draw a line from current point by (dx,dy)
  arc(x,y,r,t1,t2)        draw arc at (x,y) with radia r from angle t1 to t2
  ellipse(x,y,angle1,angle2,xRadius,yRadius)
                          draw an ellipse arc from angle1 to angle 2 with xRadius and yRadius                             as the horizontal and vertical axes at point (x,y)
  circle(x,y,r)           draw a circle at (x,y) with radia r
  oval(x,y,xr,yr)         draw an oval at (x,y) with x radia xr and y radia yr
  putpixel(x,y,color)     put pixel at (x,y) with color   

  moveto(x,y)             move current pointer to (x,y)
  moverel(dx,dy)          move current pointer by (dx,dy)

  setviewport(x1,y1,x2,y2,clip)   set view port from (x1,y2) to (x2,y2)
  setlinestyle(style,dir,thick)   set line style
  settextstyle(font,dir,size)     set text style
  settextjustify(hor,ver)
  setcolor(colorno)               set color
  setbkcolor(colorno)             set background color

  getbkcolor              get background color
  getcolor                get color
  getx                    get x of current pointer
  gety                    get y of current pointer
  getmaxx         get max x of screen
  getmaxy         get max y of screen

  plot(y,x)               plot y w.r.t. x from x=-5 to 5, from y=-5 to 5
  plot(y,x,xmin,xmax)     plot y w.r.t. x from x=xmin to xmax, from y=-5 to 5
  plot(y,x,xmin,xmax,ymin,ymax)   
                          plot y w.r.t. x from x=xmin to xmax, from y=ymin to ymax
  dotplot(x^3,x)
  dotplot(y,x,xmin,xmax)
  dotplot(y,x,xmin,xmax,ymin,ymax)

  paraplot(x(t),y(t),t)           parametric plot x(t) and y(t) w.r.t. t from t=0 to 2*pi
  paraplot(x(t),y(t),t,tmin,tmax) parametric plot x(t) and y(t) w.r.t. t from t=tmin to tmax

  polaplot(r(t),t)                polar plot r(t) w.r.t. t from t=0 to 2*pi
  polaplot(r(t),t,tmin,tmax)      polar plot x(t) and y(t) w.r.t. t from t=tmin to tmax

  dataplot([x1,x2],[y1,y2])       plot a set of data
  dataplot([x1,x2],[y1,y2],xmin,xmax,ymin,ymax)           
                plot a set of data from xmin to xmax, from ymin to ymax

  listplot([y1,y2])               plot a list of data
----------------------------------------------------------------------------------------------------------------
