ChebyshevT INDEX

CHEBYSHEVT _ _ _ _ _ _ _ _ _ _ _ _ operator

The ChebyshevT operator computes the nth Chebyshev T Polynomial (of the first kind).

syntax:

ChebyshevT(<integer>,<expression>)

examples:


ChebyshevT(3,xx); 

          2
  xx*(4*xx   - 3) 



ChebyshevT(3,4); 

  244

Chebyshev's T polynomials are computed using the recurrence relati on:

ChebyshevT(n,x) := 2x*ChebyshevT(n-1,x) - ChebyshevT(n-2,x) with

ChebyshevT(0,x) := 0 and ChebyshevT(1,x) := x

ChebyshevU INDEX

CHEBYSHEVU _ _ _ _ _ _ _ _ _ _ _ _ operator

The ChebyshevU operator returns the nth Chebyshev U Polynomial (of the second kind).

syntax:

ChebyshevU(<integer>,<expression>)

examples:


ChebyshevU(3,xx); 

          2
  4*x*(2*x   - 1) 



ChebyshevU(3,4); 

  496

Chebyshev's U polynomials are computed using the recurrence relati on:

ChebyshevU(n,x) := 2x*ChebyshevU(n-1,x) - ChebyshevU(n-2,x) with

ChebyshevU(0,x) := 0 and ChebyshevU(1,x) := 2x

HermiteP INDEX

HERMITEP _ _ _ _ _ _ _ _ _ _ _ _ operator

The HermiteP operator returns the nth Hermite Polynomial.

syntax:

HermiteP(<integer>,<expression>)

examples:


HermiteP(3,xx); 

            2
  4*xx*(2*xx   - 3) 


HermiteP(3,4); 

  464

Hermite polynomials are computed using the recurrence relation:

HermiteP(n,x) := 2x*HermiteP(n-1,x) - 2*(n-1)*HermiteP(n-2,x) with

HermiteP(0,x) := 1 and HermiteP(1,x) := 2x

LaguerreP INDEX

LAGUERREP _ _ _ _ _ _ _ _ _ _ _ _ operator

The LaguerreP operator computes the nth Laguerre Polynomial. The two argument call of LaguerreP is a (common) abbreviation of LaguerreP(n,0,x).

syntax:

LaguerreP(<integer>,<expression>) or

LaguerreP(<integer>,<expression>,<expression>)

examples:


LaguerreP(3,xx); 

       3        2
  (- xx   + 9*xx   - 18*xx + 6)/6



LaguerreP(2,3,4); 

  -2

Laguerre polynomials are computed using the recurrence relation:

LaguerreP(n,a,x) := (2n+a-1-x)/n*LaguerreP(n-1,a,x) - (n+a-1) * LaguerreP(n-2,a,x) with

LaguerreP(0,a,x) := 1 and LaguerreP(2,a,x) := -x+1+a

LegendreP INDEX

LEGENDREP _ _ _ _ _ _ _ _ _ _ _ _ operator

The binary LegendreP operator computes the nth Legendre Polynomial which is a special case of the nth Jacobi Polynomial with

LegendreP(n,x) := JacobiP(n,0,0,x)

The ternary form returns the associated Legendre Polynomial (see below).

syntax:

LegendreP(<integer>,<expression>) or

LegendreP(<integer>,<expression>,<expression>)

examples:


LegendreP(3,xx); 

          2
  xx*(5*xx   - 3)
  ----------------
         2



LegendreP(3,2,xx); 

              2
  15*xx*( - xx   + 1)

The ternary form of the operator LegendreP is the associa ted Legendre Polynomial defined as

P(n,m,x) = (-1)**m * (1-x**2)**(m/2) * df(LegendreP(n,x),x,m)

JacobiP INDEX

JACOBIP _ _ _ _ _ _ _ _ _ _ _ _ operator

The JacobiP operator computes the nth Jacobi Polynomial.

syntax:

JacobiP(<integer>,<expression>,<expression>, <expression>)

examples:


JacobiP(3,4,5,xx); 

          3         2
  7*(65*xx   - 13*xx   - 13*xx + 1)
  ----------------------------------
                  8



JacobiP(3,4,5,6); 

  94465/8

GegenbauerP INDEX

GEGENBAUERP _ _ _ _ _ _ _ _ _ _ _ _ operator

The GegenbauerP operator computes Gegenbauer's (ultraspherical) polynomials.

syntax:

GegenbauerP(<integer>,<expression>,<expression>)

examples:


GegenbauerP(3,2,xx); 

            2
  4*xx*(8*xx   - 3)



GegenbauerP(3,2,4); 

  2000

SolidHarmonicY INDEX

SOLIDHARMONICY _ _ _ _ _ _ _ _ _ _ _ _ operator

The SolidHarmonicY operator computes Solid harmonic (Laplace) polynomials.

syntax:

SolidHarmonicY(<integer>,<integer>, <expression>,<expression>,<expression>,<expression>)

examples:



SolidHarmonicY(3,-2,x,y,z,r2); 

                           2    2
  sqrt(105)*z*(-2*i*x*y + x  - y )
  ---------------------------------
         4*sqrt(pi)*sqrt(2)

SphericalHarmonicY INDEX

SPHERICALHARMONICY _ _ _ _ _ _ _ _ _ _ _ _ operator

The SphericalHarmonicY operator computes Spherical harmonic (Laplace) polynomials. These are special cases of the solid harmonic polynomials, SolidHarmonicY.

syntax:

SphericalHarmonicY(<integer>,<integer>, <expression>,<expression>)

examples:


SphericalHarmonicY(3,2,theta,phi); 


                                 2          2                               2
  sqrt(105)*cos(theta)*sin(theta) *(cos(phi) +2*cos(phi)*sin(phi)*i-sin(phi) )
  -----------------------------------------------------------------------------
                               4*sqrt(pi)*sqrt(2)

Orthogonal Polynomials INDEX

Orthogonal Polynomials

  • ChebyshevT operator

  • ChebyshevU operator

  • HermiteP operator

  • LaguerreP operator

  • LegendreP operator

  • JacobiP operator

  • GegenbauerP operator

  • SolidHarmonicY operator

  • SphericalHarmonicY operator

  • Si INDEX

    SI _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Si operator returns the Sine Integral function.

    syntax:

    Si(<expression>)

    examples:

    
    limit(Si(x),x,infinity); 
    
      pi / 2 
    
    
    on rounded; 
    
    Si(0.35); 
    
      0.347626790989
    
    

    The numeric values for the operator Si are computed via t he power series representation, which limits the argument range.

    Shi INDEX

    SHI _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Shi operator returns the hyperbolic Sine Integral function.

    syntax:

    Shi(<expression>)

    examples:

    
    df(shi(x),x); 
    
      sinh(x) / x 
    
    
    on rounded; 
    
    Shi(0.35); 
    
      0.352390716351
    
    

    The numeric values for the operator Shi are computed via the power series representation, which limits the argument range.

    s_i INDEX

    S_I _ _ _ _ _ _ _ _ _ _ _ _ operator

    The s_i operator returns the Sine Integral function si.

    syntax:

    s_i(<expression>)

    examples:

    
    s_i(xx); 
    
      (2*Si(xx) - pi) / 2 
    
    
    df(s_i(x),x); 
    
      sin(x) / x
    
    

    The operator name s_i is simplified towards SI. Since REDUCE is not case sensitive by default the name ``si'' can't be used.

    Ci INDEX

    CI _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Ci operator returns the Cosine Integral function.

    syntax:

    Ci(<expression>)

    examples:

    
    defint(cos(t)/t,t,x,infinity); 
    
      - ci (x) 
    
    
    on rounded; 
    
    Ci(0.35); 
    
      - 0.50307556932
    
    

    The numeric values for the operator Ci are computed via t he power series representation, which limits the argument range.

    Chi INDEX

    CHI _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Chi operator returns the Hyperbolic Cosine Integral function.

    syntax:

    Chi(<expression>)

    examples:

    
    defint((cosh(t)-1)/t,t,0,x); 
    
      - log(x) + psi(1) + chi(x)
    
    
    on rounded; 
    
    Chi(0.35); 
    
      - 0.44182471827
    
    

    The numeric values for the operator Chi are computed via the power series representation, which limits the argument range.

    ERF_extended INDEX

    ERF EXTENDED _ _ _ _ _ _ _ _ _ _ _ _ operator

    The special function package supplies an extended support for the erf operator which implements the error f unction

    defint(e**(-x**2),x,0,infinity) * 2/sqrt(pi)

    .

    syntax:

    erf(<expression>)

    examples:

    
    erf(-x); 
    
      - erf(x)
    
    
    on rounded; 
    
    erf(0.35); 
    
      0.379382053562
    
    

    The numeric values for the operator erf are computed via the power series representation, which limits the argument range.

    erfc INDEX

    ERFC _ _ _ _ _ _ _ _ _ _ _ _ operator

    The erfc operator returns the complementary Error function

    1 - defint(e**(-x**2),x,0,infinity) * 2/sqrt(pi)

    .

    syntax:

    erfc(<expression>)

    examples:

    
    erfc(xx); 
    
      - erf(xx) + 1
    
    

    The operator erfc is simplified towards the erf operator.

    Ei INDEX

    EI _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Ei operator returns the Exponential Integral function.

    syntax:

    Ei(<expression>)

    examples:

    
    df(ei(x),x); 
    
       x
      e
      ---
      x
    
    
    on rounded; 
    
    Ei(0.35); 
    
      - 0.0894340019184
    
    

    The numeric values for the operator Ei are computed via t he power series representation, which limits the argument range.

    Fresnel_C INDEX

    FRESNEL_C _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Fresnel_C operator represents Fresnel's Cosine function.

    syntax:

    Fresnel_C(<expression>)

    examples:

    
    int(cos(t^2*pi/2),t,0,x); 
    
      fresnel_c(x) 
    
    
    on rounded; 
    
    fresnel_c(2.1); 
    
      0.581564135061
    
    

    The operator Fresnel_C has a limited numeric evaluation o f large values of its argument.

    Fresnel_S INDEX

    FRESNEL_S _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Fresnel_S operator represents Fresnel's Sine Integral function.

    syntax:

    Fresnel_S(<expression>)

    examples:

    
    int(sin(t^2*pi/2),t,0,x); 
    
      fresnel_s(x) 
    
    
    on rounded; 
    
    fresnel_s(2.1); 
    
      0.374273359378
    
    

    The operator Fresnel_S has a limited numeric evaluation o f large values of its argument.

    Integral Functions INDEX

    Integral Functions

  • Si operator

  • Shi operator

  • s_i operator

  • Ci operator

  • Chi operator

  • ERF extended operator

  • erfc operator

  • Ei operator

  • Fresnel_C operator

  • Fresnel_S operator

  • BINOMIAL INDEX

    BINOMIAL _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Binomial operator returns the Binomial coefficient if both parameter are integer and expressions involving the Gamma function otherwise.

    syntax:

    Binomial(<integer>,<integer>)

    examples:

    
    Binomial(49,6); 
    
      13983816 
    
    
    
    Binomial(n,3); 
    
       gamma(n + 1)
      ---------------
      6*gamma(n - 2)
    
    

    The operator Binomial evaluates the Binomial coefficients from the explicit form and therefore it is not the best algorithm if you want to compute many binomial coefficients with big indices in which case a recursive algorithm is preferable.

    STIRLING1 INDEX

    STIRLING1 _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Stirling1 operator returns the Stirling Numbers S(n,m) of the first kind, i.e. the number of permutations of n symbols which have exactly m cycles (divided by (-1)**(n-m)).

    syntax:

    Stirling1(<integer>,<integer>)

    examples:

    
    Stirling1 (17,4); 
    
      -87077748875904 
    
    
    Stirling1 (n,n-1); 
    
      -gamma(n+1)
      -------------
      2*gamma(n-1)
    
    

    The operator Stirling1 evaluates the Stirling numbers of the first kind by rulesets for special cases or by a computing the closed form, which is a series involving the operators BINOMIAL and STIRLING2.

    STIRLING2 INDEX

    STIRLING2 _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Stirling1 operator returns the Stirling Numbers S(n,m) of the second kind, i.e. the number of ways of partitioning a set of n elements into m non-empty subsets.

    syntax:

    Stirling2(<integer>,<integer>)

    examples:

    
    Stirling2 (17,4); 
    
      694337290 
    
    
    Stirling2 (n,n-1); 
    
       gamma(n+1)
      -------------
      2*gamma(n-1)
    
    

    The operator Stirling2 evaluates the Stirling numbers of the second kind by rulesets for special cases or by a computing the closed form.

    Combinatorial Operators INDEX

    Combinatorial Operators

  • BINOMIAL operator

  • STIRLING1 operator

  • STIRLING2 operator

  • ThreejSymbol INDEX

    THREEJSYMBOL _ _ _ _ _ _ _ _ _ _ _ _ operator

    The ThreejSymbol operator implements the 3j symbol.

    syntax:

    ThreejSymbol(<list of j1,m1>,<list of j2,m2>, <list of j3,m3>)

    examples:

    
    
    ThreejSymbol({j+1,m},{j+1,-m},{1,0}); 
    
    
            j
      ( - 1)  *(abs(j - m + 1) - abs(j + m + 1))
      -------------------------------------------
                 3       2                    m
       2*sqrt(2*j   + 9*j   + 13*j + 6)*( - 1)
    
    

    Clebsch_Gordan INDEX

    CLEBSCH_GORDAN _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Clebsch_Gordan operator implements the Clebsch_Gordan coefficients. This is closely related to the Threejsymbol.

    syntax:

    Clebsch_Gordan(<list of j1,m1>,<list of j2,m2>, <list of j3,m3>)

    examples:

    
     Clebsch_Gordan({2,0},{2,0},{2,0}); 
    
    
         -2
      ---------
      sqrt(14)
    
    

    SixjSymbol INDEX

    SIXJSYMBOL _ _ _ _ _ _ _ _ _ _ _ _ operator

    The SixjSymbol operator implements the 6j symbol.

    syntax:

    SixjSymbol(<list of j1,j2,j3>,<list of l1,l2,l3>)

    examples:

    
    
    SixjSymbol({7,6,3},{2,4,6}); 
    
           1
      -------------
      14*sqrt(858)
    
    

    The operator SixjSymbol uses the ineq package in order to find minima and maxima for the summation index.

    3j and 6j symbols INDEX

    3j and 6j symbols

  • ThreejSymbol operator

  • Clebsch_Gordan operator

  • SixjSymbol operator

  • HYPERGEOMETRIC INDEX

    HYPERGEOMETRIC _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Hypergeometric operator provides simplifications for the generalized hypergeometric functions. The Hypergeometric operator is included in the package specfn2.

    syntax:

    hypergeometric(<list of parameters>,<list of parameters>, <argument>)

    examples:

    
    load specfn2;
    
    hypergeometric ({1/2,1},{3/2},-x^2); 
    
    
      atan(x)
      --------
         x
    
    
    hypergeometric ({},{},z); 
    
       z
      e
    
    

    The special case where the length of the first list is equal to 2 and the length of the second list is equal to 1 is often called ``the hypergeometric function'' (notated as 2F1(a1,a2,b;x)).

    MeijerG INDEX

    MEIJERG _ _ _ _ _ _ _ _ _ _ _ _ operator

    The MeijerG operator provides simplifications for Meijer's G function. The simplifications are performed towards polynomials, elementary or special functions or (generalized) hypergeometric functions.

    The MeijerG operator is included in the package specfn2.

    syntax:

    MeijerG(<list of parameters>,<list of parameters>, <argument>)

    The first element of the lists has to be the list containing the first group (mostly called ``m'' and ``n'') of parameters. This passes the four parameters of a Meijer's G function implicitly via the length of the lists.

    examples:

    
    load specfn2;
    
    MeijerG({{},1},{{0}},x); 
    
      heaviside(-x+1)
    
    
    MeijerG({{}},{{1+1/4},1-1/4},(x^2)/4) * sqrt pi;
     
    
    
                      2
      sqrt(2)*sin(x)*x
      ------------------
          4*sqrt(x)
    
    

    Many well-known functions can be written as G functions, e.g. exponentials, logarithms, trigonometric functions, Bessel functions and hypergeometric functions. The formulae can be found e.g. in

    A.P.Prudnikov, Yu.A.Brychkov, O.I.Marichev: Integrals and Series, Volume 3: More special functions, Gordon and Breach Science Publishers (1990).

    Heaviside INDEX

    HEAVISIDE _ _ _ _ _ _ _ _ _ _ _ _ operator

    The Heaviside operator returns the Heaviside function.

    Heaviside(~w) => if (w <0) then 0 else 1

    when numberp w;

    syntax:

    Heaviside(<argument>)

    This operator is often included in the result of the simplification of a generalized hypergeometric function or a MeijerG function.

    No simplification is done for this function.

    erfi INDEX

    ERFI _ _ _ _ _ _ _ _ _ _ _ _ operator

    The erfi operator returns the error function of an imaginary argument.

    erfi(~x) => 2/sqrt(pi) * defint(e**(t**2),t,0,x);

    syntax:

    erfi(<argument>)

    This operator is sometimes included in the result of the simplification of a generalized hypergeometric function or a MeijerG function.

    No simplification is done for this function.

    Miscellaneous INDEX

    Miscellaneous

  • HYPERGEOMETRIC operator

  • MeijerG operator

  • Heaviside operator

  • erfi operator

  • Special Functions INDEX

    Special Functions

  • Special Function Package introduction

  • Constants concept

  • Bernoulli Euler Zeta

  • Bessel Functions

  • Airy Functions

  • Jacobi's Elliptic Functions and Elliptic Inte grals

  • Gamma and Related Functions

  • Miscellaneous Functions

  • Orthogonal Polynomials

  • Integral Functions

  • Combinatorial Operators

  • 3j and 6j symbols

  • Miscellaneous

  • TAYLOR_introduction INDEX

    TAYLOR _ _ _ _ _ _ _ _ _ _ _ _ introduction

    This short note describes a package of REDUCE procedures that allow Taylor expansion in one or more variables and efficient manipulation of the resulting Taylor series. Capabilities include basic operations (addition, subtraction, multiplication and division) and also application of certain algebraic and transcendental functions. To a certain extent, Laurent expansion can be performed as well.

    taylor INDEX

    TAYLOR _ _ _ _ _ _ _ _ _ _ _ _ operator

    The taylor operator is used for expanding an expression into a Taylor series.

    syntax:

    taylor(<expression> ,<var>, <expression>,<number>

    {,<var>, <expression>,<number>}*)

    <expression> can be any valid REDUCE algebraic expression. <var> must be a kernel, and is the expansion variable. The <expression> following it denotes the point about which the expansion is to take place. <number> must be a non-negative integer and denotes the maximum expansion order. If more than one triple is specified taylor will expand its first argument independently with respect to all the variables. Note that once the expansion has been done it is not possible to calculate higher orders.

    Instead of a kernel, <var> may also be a list of kernels. In this case expansion will take place in a way so that the sum/ of the degrees of the kernels does not exceed the maximum expansion order. If the expansion point evaluates to the special identifier infinity, taylor tries to expand in a series in 1/<var>.

    The expansion is performed variable per variable, i.e. in the example above by first expanding exp(x^2+y^2) with respect to x and then expanding every coefficient with respect to y.

    examples:

    
        taylor(e^(x^2+y^2),x,0,2,y,0,2); 
    
    
           2    2    2  2      2  2
      1 + Y  + X  + Y *X  + O(X ,Y )   
    
    
        taylor(e^(x^2+y^2),{x,y},0,2); 
    
    
           2    2       2  2
      1 + Y  + X  + O({X ,Y })
    
    

    The following example shows the case of a non-analytical function.

    
    
        taylor(x*y/(x+y),x,0,2,y,0,2); 
    
    
      ***** Not a unit in argument to QUOTTAYLOR 
    
    

    Note that it is not generally possible to apply the standard reduce operators to a Taylor kernel. For example, part, coeff, or coeffn cannot be used. Instead, the expression at hand has to be converted to standard form first using the taylortostandard operator.

    Differentiation of a Taylor expression is possible. If you differentiate with respect to one of the Taylor variables the order will decrease by one.

    Substitution is a bit restricted: Taylor variables can only be replaced by other kernels. There is one exception to this rule: you can always substitute a Taylor variable by an expression that evaluates to a constant. Note that REDUCE will not always be able to determine that an expression is constant: an example is sin(acos(4)).

    Only simple taylor kernels can be integrated. More complicated expressions that contain Taylor kernels as parts of themselves are automatically converted into a standard representation by means of the taylortostandard operator. In this case a sui table warning is printed.

    taylorautocombine INDEX

    TAYLORAUTOCOMBINE _ _ _ _ _ _ _ _ _ _ _ _ switch

    If you set taylorautocombine to on, REDUCE automatically combines Taylor expressions during the simplification process. This is equivalent to applying taylorcombine to every expression that contains Taylor kernels. Default is on.

    taylorautoexpand INDEX

    TAYLORAUTOEXPAND _ _ _ _ _ _ _ _ _ _ _ _ switch

    taylorautoexpand makes Taylor expressions ``contagious'' in the sense that taylorcombine tries to Taylor expand all non-Taylor subexpressions and to combine the result with the rest. Default is off.

    taylorcombine INDEX

    TAYLORCOMBINE _ _ _ _ _ _ _ _ _ _ _ _ operator

    This operator tries to combine all Taylor kernels found in its argument into one. Operations currently possible are:

    _ _ _ Addition, subtraction, multiplication, and division.

    _ _ _ Roots, exponentials, and logarithms.

    _ _ _ Trigonometric and hyperbolic functions and their inverses.

    examples:

    
        hugo := taylor(exp(x),x,0,2); 
    
                      1  2      3
      HUGO := 1 + X + -*X  + O(X )
                      2
    
    
        taylorcombine log hugo; 
    
             3
      X + O(X )
    
    
        taylorcombine(hugo + x); 
    
               1  2      3
      (1 + X + -*X  + O(X )) + X
               2
    
    
        on taylorautoexpand; 
    
        taylorcombine(hugo + x); 
    
                1  2      3
      1 + 2*X + -*X  + O(X )  
                2
    
    

    Application of unary operators like log and atan will nearly always succeed. For binary operations their arguments have to be Taylor kernels with the same template. This means that the expansion variable and the expansion point must match. Expansion order is not so important, different order usually means that one of them is truncated before doing the operation.

    If taylorkeeporiginal is set to on and if all Taylor kernels in its argument have their original expressions kept taylorcombine will also combine these and store the result as the original expression of the resulting Taylor kernel. There is also the switch taylorautoexpand.

    There are a few restrictions to avoid mathematically undefined expressions: it is not possible to take the logarithm of a Taylor kernel which has no terms (i.e. is zero), or to divide by such a beast. There are some provisions made to detect singularities during expansion: poles that arise because the denominator has zeros at the expansion point are detected and properly treated, i.e. the Taylor kernel will start with a negative power. (This is accomplished by expanding numerator and denominator separately and combining the results.) Essential singularities of the known functions (see above) are handled correctly.

    taylorkeeporiginal INDEX

    TAYLORKEEPORIGINAL _ _ _ _ _ _ _ _ _ _ _ _ switch

    taylorkeeporiginal, if set to on, forces the taylor and all Taylor kernel manipulation ope rators to keep the original expression, i.e. the expression that was Taylor expanded. All operations performed on the Taylor kernels are also applied to this expression which can be recovered using the operator taylororiginal. Default is off.

    taylororiginal INDEX

    TAYLORORIGINAL _ _ _ _ _ _ _ _ _ _ _ _ operator

    Recovers the original expression (the one that was expanded) from the Taylor kernel that is given as its argument.

    syntax:

    taylororiginal(<expression>) or taylororiginal <simple_expression>

    examples:

    
        hugo := taylor(exp(x),x,0,2); 
    
                      1  2      3
      HUGO := 1 + X + -*X  + O(X )
                      2
    
    
        taylororiginal hugo; 
    
      ***** Taylor kernel doesn't have an original part in TAYLORORIGINAL
    
    
        on taylorkeeporiginal; 
    
        hugo := taylor(exp(x),x,0,2); 
    
                      1  2      3
      HUGO := 1 + X + -*X  + O(X )
                      2
    
    
        taylororiginal hugo; 
    
       X
      E   
    
    

    An error is signalled if the argument is not a Taylor kernel or if the original expression was not kept, i.e. if taylorkeeporiginal was set off durin g expansion.

    taylorprintorder INDEX

    TAYLORPRINTORDER _ _ _ _ _ _ _ _ _ _ _ _ switch

    taylorprintorder, if set to on, causes the remainder to be printed in big-O notation. Otherwise, three dots are printed. Default is on.

    taylorprintterms INDEX

    TAYLORPRINTTERMS _ _ _ _ _ _ _ _ _ _ _ _ variable

    Only a certain number of (non-zero) coefficients are printed. If there are more, an expression of the form n terms is printed to indicate how many non-zero terms have been suppressed. The number of terms printed is given by the value of the shared algebraic variable taylorprintterms. Allowed values are integers and the special identifier all. The latter setting specifies that all terms are to be printed. The default setting is 5.

    examples:

    
        taylor(e^(x^2+y^2),x,0,4,y,0,4); 
    
    
           2   1  4    2    2  2                              5  5
      1 + Y  + -*Y  + X  + Y *X  +             (4 terms) + O(X ,Y )
               2
    
    
        taylorprintterms := all; 
    
      TAYLORPRINTTERMS := ALL 
    
    
        taylor(e^(x^2+y^2),x,0,4,y,0,4); 
    
    
           2   1  4    2    2  2   1  4  2   1  4   1  2  4
      1 + Y  + -*Y  + X  + Y *X  + -*Y *X  + -*X  + -*Y *X
               2                   2         2      2
         1  4  4      5  5
       + -*Y *X  + O(X ,Y )
         4
          
    
    

    taylorrevert INDEX

    TAYLORREVERT _ _ _ _ _ _ _ _ _ _ _ _ operator

    taylorrevert allows reversion of a Taylor series of a function f, i.e., to compute the first terms of the expansion of the inverse of f from the expansion of f.

    syntax:

    taylorrevert(<expression>, <var>,<var>)

    The first argument must evaluate to a Taylor kernel with the second argument being one of its expansion variables.

    examples:

    
        taylor(u - u**2,u,0,5); 
    
           2      6
      U - U  + O(U ) 
    
    
        taylorrevert (ws,u,x); 
    
           2      3      4       5      6
      X + X  + 2*X  + 5*X  + 14*X  + O(X )  
    
    

    taylorseriesp INDEX

    TAYLORSERIESP _ _ _ _ _ _ _ _ _ _ _ _ operator

    This operator may be used to determine if its argument is a Taylor kernel.

    syntax:

    taylorseriesp(<expression>) or taylorseriesp <simple_expression>

    examples:

    
        hugo := taylor(exp(x),x,0,2); 
    
                      1  2      3
      HUGO := 1 + X + -*X  + O(X )
                      2
    
    
        if taylorseriesp hugo then OK;
    
      OK 
    
    
        if taylorseriesp(hugo + y) then OK else NO; 
    
    
      NO  
    
    

    Note that this operator is subject to the same restrictions as, e.g., ordp or numberp, i.e. it may only be used in boolean expressions in if or let statements.

    taylortemplate INDEX

    TAYLORTEMPLATE _ _ _ _ _ _ _ _ _ _ _ _ operator

    The template of a Taylor kernel, i.e. the list of all variables with respect to which expansion took place together with expansion point and order can be extracted using

    syntax:

    taylortemplate(<expression>) or taylortemplate <simple_expression>

    This returns a list of lists with the three elements (VAR,VAR0,ORDER). An error is signalled if the argument is not a Taylor kernel.

    examples:

    
        hugo := taylor(exp(x),x,0,2); 
    
                      1  2      3
      HUGO := 1 + X + -*X  + O(X )
                      2
    
    
        taylortemplate hugo; 
    
      {{X,0,2}}  
    
    

    taylortostandard INDEX

    TAYLORTOSTANDARD _ _ _ _ _ _ _ _ _ _ _ _ operator

    This operator converts all Taylor kernels in its argument into standard form and resimplifies the result.

    syntax:

    taylortostandard(<expression>) or taylortostandard <simple_expression>

    examples:

    
        hugo := taylor(exp(x),x,0,2); 
    
                      1  2      3
      HUGO := 1 + X + -*X  + O(X )
                      2
    
    
        taylortostandard hugo; 
    
       2
      X  + 2*X + 2
      ------------  
           2
    
    

    Taylor series INDEX

    Taylor series

  • TAYLOR introduction

  • taylor operator

  • taylorautocombine switch

  • taylorautoexpand switch

  • taylorcombine operator

  • taylorkeeporiginal switch

  • taylororiginal operator

  • taylorprintorder switch

  • taylorprintterms variable

  • taylorrevert operator

  • taylorseriesp operator

  • taylortemplate operator

  • taylortostandard operator

  • GNUPLOT_and_REDUCE INDEX

    GNUPLOT AND REDUCE _ _ _ _ _ _ _ _ _ _ _ _ introduction

    The GNUPLOT system provides easy to use graphics output for curves or surfaces which are defined by formulas and/or data sets. GNUPLOT supports a great variety of output devices such as X-windows, VGA screen, postscript, picTeX. The REDUCE GNUPLOT package lets one use the GNUPLOT graphical output directly from inside REDUCE, either for the interactive display of curves/surfaces or for the production of pictures on paper.

    Note that this package may not be supported on all system platforms.

    For a detailed description you should read the GNUPLOT system documentation, available together with the GNUPLOT installation material from several servers by anonymous FTP.

    The REDUCE developers thank the GNUPLOT people for their permission to distribute GNUPLOT together with REDUCE.