2210
File: maxima.info, Node: Orthogonal Polynomials, Next: Elliptic Functions, Prev: Special Functions, Up: Top
2212
17 Orthogonal Polynomials
2213
*************************
2217
* Introduction to Orthogonal Polynomials::
2218
* Definitions for Orthogonal Polynomials::
2221
File: maxima.info, Node: Introduction to Orthogonal Polynomials, Next: Definitions for Orthogonal Polynomials, Up: Orthogonal Polynomials
2223
17.1 Introduction to Orthogonal Polynomials
2224
===========================================
2226
The `specfun' package contains Maxima code for the evaluation of all
2227
orthogonal polynomials listed in Chapter 22 of Abramowitz and Stegun.
2228
These include Chebyshev, Laguerre, Hermite, Jacobi, Legendre, and
2229
ultraspherical (Gegenbauer) polynomials. Additionally, `specfun'
2230
contains code for spherical Bessel, spherical Hankel, and spherical
2231
harmonic functions. The `specfun' package is not part of Maxima proper;
2232
it is loaded at request of the user via `load' or automatically via the
2235
The following table lists each function in `specfun', its Maxima
2236
name, restrictions on its arguments, and a reference to the algorithm
2237
`specfun' uses to evaluate it. With few exceptions, `specfun' follows
2238
the conventions of Abramowitz and Stegun. In all cases, m and n must
2241
A&S refers to Abramowitz and Stegun, _Handbook of Mathematical
2242
Functions_ (10th printing, December 1972), G&R to Gradshteyn and Ryzhik,
2243
_Table of Integrals, Series, and Products_ (1980 corrected and enlarged
2244
edition), and Merzbacher to _Quantum Mechanics_ (second edition, 1970).
2246
_Function_ _Maxima Name_ _Restrictions_ _Reference(s)_
2247
Chebyshev T chebyshev_t(n, x) n > -1 A&S 22.5.31
2248
Chebyshev U chebyshev_u(n, x) n > -1 A&S 22.5.32
2249
generalized gen_laguerre(n,a,x)n > -1 A&S page 789
2251
Laguerre laguerre(n,x) n > -1 A&S 22.5.67
2252
Hermite hermite(n,x) n > -1 A&S 22.4.40,
2254
Jacobi jacobi_p(n,a,b,x) n > -1, a, b > A&S page 789
2256
associated assoc_legendre_p(n,m,x)n > -1 A&S 22.5.37,
2257
Legendre P 8.6.6, 8.2.5
2258
associated assoc_legendre_q(n,m,x)n > -1, m > -1 G & R 8.706
2260
Legendre P legendre_p(n,m,x) n > -1 A&S 22.5.35
2261
Legendre Q legendre_q(n,m,x) n > -1 A&S 8.6.19
2262
spherical Hankel spherical_hankel1(n,n > -1 A&S 10.1.36
2264
spherical Hankel spherical_hankel2(n,n > -1 A&S 10.1.17
2266
spherical Bessel spherical_bessel_j(n,x)n > -1 A&S 10.1.8,
2268
spherical Bessel spherical_bessel_y(n,x)n > -1 A&S 10.1.9,
2270
spherical spherical_harmonic(n,m,x,y)n > -1, |m| <= n Merzbacher 9.64
2272
ultraspherical ultraspherical(n,a,x) n > -1 A&S 22.5.27
2275
The `specfun' package is primarily intended for symbolic
2276
computation. It is hoped that it gives accurate floating point results
2277
as well; however, no claims are made that the algorithms are well
2278
suited for numerical evaluation. Some effort, however, has been made
2279
to provide good numerical performance. When all arguments, except for
2280
the order, are floats (but not bigfloats), many functions in `specfun'
2281
call a float modedeclared version of the Jacobi function. This greatly
2282
speeds floating point evaluation of the orthogonal polynomials.
2284
`specfun' handles most domain errors by returning an unevaluated
2285
function. No simplification rules (based on recursion relations) are
2286
defined for unevaluated functions. It is possible for an expression
2287
involving sums of unevaluated special functions to vanish, yet Maxima
2288
is unable to reduce it to zero.
2290
`load ("specfun")' loads the `specfun' package. Alternatively,
2291
`setup_autoload' causes the package to be loaded when one of the
2292
`specfun' functions appears in an expression. `setup_autoload' may
2293
appear at the command line or in the `maxima-init.mac' file. See
2296
An example use of `specfun' is
2298
(%i1) load ("specfun")$
2299
(%i2) [hermite (0, x), hermite (1, x), hermite (2, x)];
2301
(%o2) [1, 2 x, - 2 (1 - 2 x )]
2302
(%i3) diff (hermite (n, x), x);
2303
(%o3) 2 n hermite(n - 1, x)
2305
Generally, compiled code runs faster than translated code; however,
2306
translated code may be better for program development.
2308
Some functions (namely `jacobi_p', `ultraspherical', `chebyshev_t',
2309
`chebyshev_u', and `legendre_p'), return a series representation when
2310
the order is a symbolic integer. The series representation is not used
2311
by `specfun' for any computations, but it may be simplified by Maxima
2312
automatically, or it may be possible to use the series to evaluate the
2313
function through further manipulations. For example:
2315
(%i1) load ("specfun")$
2316
(%i2) legendre_p (n, x);
2317
(%o2) legendre_p(n, x)
2318
(%i3) ultraspherical (n, 3/2, 2);
2319
genfact(3, n, - 1) jacobi_p(n, 1, 1, 2)
2320
(%o3) ---------------------------------------
2322
(%i4) declare (n, integer)$
2323
(%i5) legendre_p (n, x);
2327
(%o5) ( > binomial(n, i%) binomial(n, n - i%) (x - 1)
2333
(x + 1) + (x + 1) + (x - 1) )/2
2334
(%i6) ultraspherical (n, 3/2, 2);
2338
(%o6) genfact(3, n, - 1) ( > 3 binomial(n + 1, i%)
2344
binomial(n + 1, n - i%) + (n + 1) 3 + n + 1)
2347
/(genfact(2, n, - 1) 2 )
2349
The first and last terms of the sum are added outside the summation.
2350
Removing these two terms avoids Maxima bugs associated with 0^0 terms
2351
in a sum that should evaluate to 1, but evaluate to 0 in a Maxima
2352
summation. Because the sum index runs from 1 to n - 1, the lower sum
2353
index will exceed the upper sum index when n = 0; setting `sumhack' to
2354
true provides a fix. For example:
2356
(%i1) load ("specfun")$
2357
(%i2) declare (n, integer)$
2358
(%i3) e: legendre_p(n,x)$
2359
(%i4) ev (e, sum, n=0);
2360
Lower bound to sum: 1
2361
is greater than the upper bound: - 1
2362
-- an error. Quitting. To debug this try debugmode(true);
2363
(%i5) ev (e, sum, n=0, sumhack=true);
2366
Most functions in `specfun' have a `gradef' property; derivatives
2367
with respect to the order or other function parameters are undefined,
2368
and an attempt to compute such a derivative yields an error message.
2370
The `specfun' package and its documentation were written by Barton
2371
Willis of the University of Nebraska at Kearney. It is released under
2372
the terms of the General Public License (GPL). Send bug reports and
2373
comments on this package to willisb@unk.edu. In your report, please
2374
include the Maxima version, as reported by `build_info()', and the
2375
`specfun' version, as reported by `get ('specfun, 'version)'.
2378
File: maxima.info, Node: Definitions for Orthogonal Polynomials, Prev: Introduction to Orthogonal Polynomials, Up: Orthogonal Polynomials
2380
17.2 Definitions for Orthogonal Polynomials
2381
===========================================
2383
-- Function: assoc_legendre_p (<n>, <m>, <x>)
2384
Returns the associated Legendre function of the first kind for
2385
integers n > -1 and m > -1. When | m | > n and n >= 0, we
2386
have assoc_legendre_p (n, m, x) = 0. Reference: A&S 22.5.37
2387
page 779, A&S 8.6.6 (second equation) page 334, and A&S 8.2.5
2390
`load ("specfun")' loads this function.
2392
See *Note assoc_legendre_q::, *Note legendre_p::, and *Note
2395
-- Function: assoc_legendre_q (<n>, <m>, <x>)
2396
Returns the associated Legendre function of the second kind for
2397
integers n > -1 and m > -1.
2399
Reference: Gradshteyn and Ryzhik 8.706 page 1000.
2401
`load ("specfun")' loads this function.
2403
See also *Note assoc_legendre_p::, *Note legendre_p::, and *Note
2406
-- Function: chebyshev_t (<n>, <x>)
2407
Returns the Chebyshev function of the first kind for integers n
2410
Reference: A&S 22.5.31 page 778 and A&S 6.1.22 page 256.
2412
`load ("specfun")' loads this function.
2414
See also *Note chebyshev_u::.
2417
-- Function: chebyshev_u (<n>, <x>)
2418
Returns the Chebyshev function of the second kind for integers n
2421
Reference: A&S, 22.8.3 page 783 and A&S 6.1.22 page 256.
2423
`load ("specfun")' loads this function.
2425
See also *Note chebyshev_t::.
2428
-- Function: gen_laguerre (<n>, <a>, <x>)
2429
Returns the generalized Laguerre polynomial for integers n > -1.
2431
`load ("specfun")' loads this function.
2433
Reference: table on page 789 in A&S.
2435
-- Function: hermite (<n>, <x>)
2436
Returns the Hermite polynomial for integers n > -1.
2438
`load ("specfun")' loads this function.
2440
Reference: A&S 22.5.40 and 22.5.41, page 779.
2443
-- Function: jacobi_p (<n>, <a>, <b>, <x>)
2444
Returns the Jacobi polynomial for integers n > -1 and a and b
2445
symbolic or a > -1 and b > -1. (The Jacobi polynomials are
2446
actually defined for all a and b ; however, the Jacobi
2447
polynomial weight (1-x)^a(1+x)^b isn't integrable for a <= -1 or
2450
When a, b, and x are floats (but not bfloats) specfun calls a
2451
special modedeclared version of jacobi_p. For numerical values,
2452
the modedeclared version is much faster than the other version.
2453
Many functions in specfun are computed as a special case of the
2454
Jacobi polynomials; they also enjoy the speed boost from the
2455
modedeclared version of jacobi.
2457
If n has been declared to be an integer, jacobi_p (n, a, b, x)
2458
returns a summation representation for the Jacobi function.
2459
Because Maxima simplifies 0^0 to 0 in a sum, two terms of the
2460
sum are added outside the summation.
2462
`load ("specfun")' loads this function.
2464
Reference: table on page 789 in A&S.
2467
-- Function: laguerre (<n>, <x>)
2468
Returns the Laguerre polynomial for integers n > -1.
2470
Reference: A&S 22.5.16, page 778 and A&S page 789.
2472
`load ("specfun")' loads this function.
2474
See also *Note gen_laguerre::.
2477
-- Function: legendre_p (<n>, <x>)
2478
Returns the Legendre polynomial of the first kind for integers n
2481
Reference: A&S 22.5.35 page 779.
2483
`load ("specfun")' loads this function.
2485
See *Note legendre_q::.
2488
-- Function: legendre_q (<n>, <x>)
2489
Returns the Legendre polynomial of the first kind for integers n
2492
Reference: A&S 8.6.19 page 334.
2494
`load ("specfun")' loads this function.
2496
See also *Note legendre_p::.
2499
-- Function: spherical_bessel_j (<n>, <x>)
2500
Returns the spherical Bessel function of the first kind for
2503
Reference: A&S 10.1.8 page 437 and A&S 10.1.15 page 439.
2505
`load ("specfun")' loads this function.
2507
See also *Note spherical_hankel1::, *Note spherical_hankel2::, and
2508
*Note spherical_bessel_y::.
2511
-- Function: spherical_bessel_y (<n>, <x>)
2512
Returns the spherical Bessel function of the second kind for
2515
Reference: A&S 10.1.9 page 437 and 10.1.15 page 439.
2517
`load ("specfun")' loads this function.
2519
See also *Note spherical_hankel1::, *Note spherical_hankel2::, and
2520
*Note spherical_bessel_y::.
2523
-- Function: spherical_hankel1 (<n>, <x>)
2524
Returns the spherical hankel function of the first kind for
2527
Reference: A&S 10.1.36 page 439.
2529
`load ("specfun")' loads this function.
2531
See also *Note spherical_hankel2::, *Note spherical_bessel_j::, and
2532
*Note spherical_bessel_y::.
2535
-- Function: spherical_hankel2 (<n>, <x>)
2536
Returns the spherical hankel function of the second kind for
2539
Reference: A&S 10.1.17 page 439.
2541
`load ("specfun")' loads this function.
2543
See also *Note spherical_hankel1::, *Note spherical_bessel_j::, and
2544
*Note spherical_bessel_y::.
2547
-- Function: spherical_harmonic (<n>, <m>, <x>, <y>)
2548
Returns the spherical harmonic function for integers n > -1 and
2551
Reference: Merzbacher 9.64.
2553
`load ("specfun")' loads this function.
2555
See also *Note assoc_legendre_p::.
2558
-- Function: ultraspherical (<n>, <a>, <x>)
2559
Returns the ultraspherical polynomials for integers n > -1. The
2560
ultraspherical polynomials are also known as Gegenbauer
2563
Reference: A&S 22.5.27
2565
`load ("specfun")' loads this function.
2567
See also *Note jacobi_p::.
2571
File: maxima.info, Node: Elliptic Functions, Next: Limits, Prev: Orthogonal Polynomials, Up: Top
2573
18 Elliptic Functions
2324
File: maxima.info, Node: Elliptic Functions, Next: Limits, Prev: Special Functions, Up: Top
2326
17 Elliptic Functions
2574
2327
*********************
5952
-- Function: interpolate (<f>(<x>), <x>, <a>, <b>)
5953
-- Function: interpolate (<f>, <a>, <b>)
5806
-- Function: find_root (<f>(<x>), <x>, <a>, <b>)
5807
-- Function: find_root (<f>, <a>, <b>)
5954
5808
Finds the zero of function <f> as variable <x> varies over the
5955
5809
range `[<a>, <b>]'. The function must have a different sign at
5956
5810
each endpoint. If this condition is not met, the action of the
5957
function is governed by `intpolerror'. If `intpolerror' is `true'
5958
then an error occurs, otherwise the value of `intpolerror' is
5959
returned (thus for plotting `intpolerror' might be set to 0.0).
5960
Otherwise (given that Maxima can evaluate the first argument in
5961
the specified range, and that it is continuous) `interpolate' is
5962
guaranteed to come up with the zero (or one of them if there is
5963
more than one zero). The accuracy of `interpolate' is governed by
5964
`intpolabs' and `intpolrel' which must be non-negative floating
5965
point numbers. `interpolate' will stop when the first arg
5966
evaluates to something less than or equal to `intpolabs' or if
5967
successive approximants to the root differ by no more than
5968
`intpolrel * <one of the approximants>'. The default values of
5969
`intpolabs' and `intpolrel' are 0.0 so `interpolate' gets as good
5970
an answer as is possible with the single precision arithmetic we
5971
have. The first arg may be an equation. The order of the last
5972
two args is irrelevant. Thus
5811
function is governed by `find_root_error'. If `find_root_error'
5812
is `true' then an error occurs, otherwise the value of
5813
`find_root_error' is returned (thus for plotting `find_root_error'
5814
might be set to 0.0). Otherwise (given that Maxima can evaluate
5815
the first argument in the specified range, and that it is
5816
continuous) `find_root' is guaranteed to come up with the zero (or
5817
one of them if there is more than one zero). The accuracy of
5818
`find_root' is governed by `find_root_abs' and `find_root_rel'
5819
which must be non-negative floating point numbers. `find_root'
5820
will stop when the first arg evaluates to something less than or
5821
equal to `find_root_abs' or if successive approximants to the root
5822
differ by no more than `find_root_rel * <one of the approximants>'.
5823
The default values of `find_root_abs' and `find_root_rel' are 0.0
5824
so `find_root' gets as good an answer as is possible with the
5825
single precision arithmetic we have. The first arg may be an
5826
equation. The order of the last two args is irrelevant. Thus
5974
interpolate (sin(x) = x/2, x, %pi, 0.1);
5828
find_root (sin(x) = x/2, x, %pi, 0.1);
5976
5830
is equivalent to
5978
interpolate (sin(x) = x/2, x, 0.1, %pi);
5832
find_root (sin(x) = x/2, x, 0.1, %pi);
5980
5834
The method used is a binary search in the range specified by the
5981
5835
last two args. When it thinks the function is close enough to
5982
5836
being linear, it starts using linear interpolation.
5984
5840
(%i1) f(x) := sin(x) - x/2;
5986
5842
(%o1) f(x) := sin(x) - -
5988
(%i2) interpolate (sin(x) - x/2, x, 0.1, %pi);
5844
(%i2) find_root (sin(x) - x/2, x, 0.1, %pi);
5989
5845
(%o2) 1.895494267033981
5990
(%i3) interpolate (sin(x) = x/2, x, 0.1, %pi);
5846
(%i3) find_root (sin(x) = x/2, x, 0.1, %pi);
5991
5847
(%o3) 1.895494267033981
5992
(%i4) interpolate (f(x), x, 0.1, %pi);
5848
(%i4) find_root (f(x), x, 0.1, %pi);
5993
5849
(%o4) 1.895494267033981
5994
(%i5) interpolate (f, 0.1, %pi);
5850
(%i5) find_root (f, 0.1, %pi);
5995
5851
(%o5) 1.895494267033981
5997
There is also a Newton method interpolation routine. See `newton'.
6000
-- Option variable: intpolabs
5854
-- Option variable: find_root_abs
6001
5855
Default value: 0.0
6003
`intpolabs' is the accuracy of the `interpolate' command is
6004
governed by `intpolabs' and `intpolrel' which must be non-negative
6005
floating point numbers. `interpolate' will stop when the first
6006
arg evaluates to something less than or equal to `intpolabs' or if
6007
successive approximants to the root differ by no more than
6008
`intpolrel * <one of the approximants>'. The default values of
6009
`intpolabs' and `intpolrel' are 0.0 so `interpolate' gets as good
6010
an answer as is possible with the single precision arithmetic we
6014
-- Option variable: intpolerror
5857
`find_root_abs' is the accuracy of the `find_root' command is
5858
governed by `find_root_abs' and `find_root_rel' which must be
5859
non-negative floating point numbers. `find_root' will stop when
5860
the first arg evaluates to something less than or equal to
5861
`find_root_abs' or if successive approximants to the root differ
5862
by no more than `find_root_rel * <one of the approximants>'. The
5863
default values of `find_root_abs' and `find_root_rel' are 0.0 so
5864
`find_root' gets as good an answer as is possible with the single
5865
precision arithmetic we have.
5868
-- Option variable: find_root_error
6015
5869
Default value: `true'
6017
`intpolerror' governs the behavior of `interpolate'. When
6018
`interpolate' is called, it determines whether or not the function
6019
to be interpolated satisfies the condition that the values of the
5871
`find_root_error' governs the behavior of `find_root'. When
5872
`find_root' is called, it determines whether or not the function
5873
to be solved satisfies the condition that the values of the
6020
5874
function at the endpoints of the interpolation interval are
6021
5875
opposite in sign. If they are of opposite sign, the interpolation
6022
proceeds. If they are of like sign, and `intpolerror' is `true',
6023
then an error is signaled. If they are of like sign and
6024
`intpolerror' is not `true', the value of `intpolerror' is
6025
returned. Thus for plotting, `intpolerror' might be set to 0.0.
6028
-- Option variable: intpolrel
5876
proceeds. If they are of like sign, and `find_root_error' is
5877
`true', then an error is signaled. If they are of like sign and
5878
`find_root_error' is not `true', the value of `find_root_error' is
5879
returned. Thus for plotting, `find_root_error' might be set to
5883
-- Option variable: find_root_rel
6029
5884
Default value: 0.0
6031
`intpolrel' is the accuracy of the `interpolate' command is
6032
governed by `intpolabs' and `intpolrel' which must be non-negative
6033
floating point numbers. `interpolate' will stop when the first
6034
arg evaluates to something less than or equal to `intpolabs' or if
6035
successive approximants to the root differ by no more than
6036
`intpolrel * <one of the approximants>'. The default values of
6037
`intpolabs' and `intpolrel' are 0.0 so `interpolate' gets as good
6038
an answer as is possible with the single precision arithmetic we
6042
-- Function: newton (<expr>, <x>, <x_0>, <eps>)
6043
Interpolation by Newton's method. `load ("newton1")' loads this
6046
`newton' can handle some expressions that `interpolate' refuses to
6047
handle, since `interpolate' requires that everything evaluate to a
6048
floating point number. Thus `newton (x^2 - a^2, x, a/2, a^2/100)'
6049
complains that it can't tell if `6.098490481853958E-4 a^2 <
6050
a^2/100'. After `assume (a>0)', the same function call succeeds,
6051
yielding a symbolic result, `1.00030487804878 a'.
6053
On the other hand, `interpolate (x^2 - a^2, x, a/2, 2*a)' complains
6054
that `0.5 a' is not a floating point number.
6056
An adaptive integrator which uses the Newton-Cotes 8 panel
6057
quadrature rule is available. See `qq'.
5886
`find_root_rel' is the accuracy of the `find_root' command is
5887
governed by `find_root_abs' and `find_root_rel' which must be
5888
non-negative floating point numbers. `find_root' will stop when
5889
the first arg evaluates to something less than or equal to
5890
`find_root_abs' or if successive approximants to the root differ
5891
by no more than `find_root_rel * <one of the approximants>'. The
5892
default values of `find_root_abs' and `find_root_rel' are 0.0 so
5893
`find_root' gets as good an answer as is possible with the single
5894
precision arithmetic we have.
6061
5898
File: maxima.info, Node: Definitions for Fourier Series, Prev: Definitions for Numerical, Up: Numerical
6063
24.4 Definitions for Fourier Series
5900
23.4 Definitions for Fourier Series
6064
5901
===================================
6066
5903
-- Function: equalp (<x>, <y>)
7686
7576
File: maxima.info, Node: Affine, Next: itensor, Prev: Matrices and Linear Algebra, Up: Top
7693
7583
* Definitions for Affine::
7586
File: maxima.info, Node: Definitions for Affine, Prev: Affine, Up: Affine
7588
27.1 Definitions for Affine
7589
===========================
7591
-- Function: fast_linsolve ([<expr_1>, ..., <expr_m>], [<x_1>, ...,
7593
Solves the simultaneous linear equations <expr_1>, ..., <expr_m>
7594
for the variables <x_1>, ..., <x_n>. Each <expr_i> may be an
7595
equation or a general expression; if given as a general
7596
expression, it is treated as an equation of the form `<expr_i> =
7599
The return value is a list of equations of the form `[<x_1> =
7600
<a_1>, ..., <x_n> = <a_n>]' where <a_1>, ..., <a_n> are all free
7601
of <x_1>, ..., <x_n>.
7603
`fast_linsolve' is faster than `linsolve' for system of equations
7607
-- Function: grobner_basis ([<expr_1>, ..., <expr_m>])
7608
Returns a Groebner basis for the equations <expr_1>, ..., <expr_m>.
7609
The function `polysimp' can then be used to simplify other
7610
functions relative to the equations.
7612
grobner_basis ([3*x^2+1, y*x])$
7614
polysimp (y^2*x + x^3*9 + 2) ==> -3*x + 2
7616
`polysimp(f)' yields 0 if and only if <f> is in the ideal
7617
generated by <expr_1>, ..., <expr_m>, that is, if and only if <f>
7618
is a polynomial combination of the elements of <expr_1>, ...,
7622
-- Function: set_up_dot_simplifications (<eqns>,
7623
<check_through_degree>)
7624
-- Function: set_up_dot_simplifications (<eqns>)
7625
The <eqns> are polynomial equations in non commutative variables.
7626
The value of `current_variables' is the list of variables used for
7627
computing degrees. The equations must be homogeneous, in order
7628
for the procedure to terminate.
7630
If you have checked overlapping simplifications in
7631
`dot_simplifications' above the degree of <f>, then the following
7632
is true: `dotsimp (<f>)' yields 0 if and only if <f> is in the
7633
ideal generated by the equations, i.e., if and only if <f> is a
7634
polynomial combination of the elements of the equations.
7636
The degree is that returned by `nc_degree'. This in turn is
7637
influenced by the weights of individual variables.
7640
-- Function: declare_weight (<x_1>, <w_1>, ..., <x_n>, <w_n>)
7641
Assigns weights <w_1>, ..., <w_n> to <x_1>, ..., <x_n>,
7642
respectively. These are the weights used in computing `nc_degree'.
7645
-- Function: nc_degree (<p>)
7646
Returns the degree of a noncommutative polynomial <p>. See
7650
-- Function: dotsimp (<f>)
7651
Returns 0 if and only if <f> is in the ideal generated by the
7652
equations, i.e., if and only if <f> is a polynomial combination of
7653
the elements of the equations.
7656
-- Function: fast_central_elements ([<x_1>, ..., <x_n>], <n>)
7657
If `set_up_dot_simplifications' has been previously done, finds
7658
the central polynomials in the variables <x_1>, ..., <x_n> in the
7662
set_up_dot_simplifications ([y.x + x.y], 3);
7663
fast_central_elements ([x, y], 2);
7667
-- Function: check_overlaps (<n>, <add_to_simps>)
7668
Checks the overlaps thru degree <n>, making sure that you have
7669
sufficient simplification rules in each degree, for `dotsimp' to
7670
work correctly. This process can be speeded up if you know before
7671
hand what the dimension of the space of monomials is. If it is of
7672
finite global dimension, then `hilbert' should be used. If you
7673
don't know the monomial dimensions, do not specify a
7674
`rank_function'. An optional third argument `reset', `false' says
7675
don't bother to query about resetting things.
7678
-- Function: mono ([<x_1>, ..., <x_n>], <n>)
7679
Returns the list of independent monomials relative to the current
7680
dot simplifications of degree <n> in the variables <x_1>, ...,
7684
-- Function: monomial_dimensions (<n>)
7685
Compute the Hilbert series through degree <n> for the current
7689
-- Function: extract_linear_equations ([<p_1>, ..., <p_n>], [<m_1>,
7691
Makes a list of the coefficients of the noncommutative polynomials
7692
<p_1>, ..., <p_n> of the noncommutative monomials <m_1>, ...,
7693
<m_n>. The coefficients should be scalars. Use
7694
`list_nc_monomials' to build the list of monomials.
7697
-- Function: list_nc_monomials ([<p_1>, ..., <p_n>])
7698
-- Function: list_nc_monomials (<p>)
7699
Returns a list of the non commutative monomials occurring in a
7700
polynomial <p> or a list of polynomials <p_1>, ..., <p_n>.
7703
-- Option variable: all_dotsimp_denoms
7704
Default value: `false'
7706
When `all_dotsimp_denoms' is a list, the denominators encountered
7707
by `dotsimp' are appended to the list. `all_dotsimp_denoms' may
7708
be initialized to an empty list `[]' before calling `dotsimp'.
7710
By default, denominators are not collected by `dotsimp'.
7714
File: maxima.info, Node: itensor, Next: ctensor, Prev: Affine, Up: Top
7721
* Introduction to itensor::
7722
* Definitions for itensor::
added
removed
doc/info/maxima.info-2
