[Date Index]
[Thread Index]
[Author Index]
MathTensor
*To*: mathgroup at yoda.physics.unc.edu
*Subject*: MathTensor
*From*: Steven M. Christensen <mathtensor>
*Date*: Thu, 20 Aug 92 03:32:19 EDT
MathGroupers:
This is our periodic posting of information on MathTensor which
is now in version 2.1. I would appreciate it if you would pass
this onto any friends, colleagues, or others who might be
interested. Sales of MathTensor indirectly support our other efforts
with Mathematica like MathGroup.
Thanks.
Steve Christensen
------------cut here--------------------------------
MathTensor(tm) Information Sheet
Valid after May 15, 1992
Hardware Requirements:
MathTensor requires approximately 2 megabytes of disk space.
It is recommended that a workstation have at least 8 megabytes
of RAM memory. The Macintosh version runs on machines with
8 megabytes or more. 386 versions require at least 5 megabytes
of memory, but more is HIGHLY recommended. The Windows 3.1 version
works with 8 megabytes of RAM or more.
Software Requirements:
MathTensor requires Mathematica 1.2, 2.0, or greater.
Contact:
MathSolutions, Inc.
P.O. Box 16175
Chapel Hill, NC 27516
Telephone/Answering Machine/FAX: 919-967-9853
Email: mathtensor at wri.com
* MathTensor Product Price List:
(Right-to-Use License)
Retail Upgrades/yr Media/Shipping
Microcomputers: $500 $150 $50
Workstations: $750 $200 $50
Servers: $3000 $1000 $50 (one copy)
Extra Manuals: $25 Federal Express Delivery add: $35.00
For definitions of Microcomputers, Workstations and Servers, see the next page.
Educational discount available only in the USA.
Upgrades and updates are only sent to users with Upgrade Contracts.
Volume discounts available.
** North Carolina residents add 6% sales tax.
** Support contracts will be available.
** Purchase orders are accepted.
** Payment is due upon receipt of software shipment.
** Prices, availability and details of functionality of any products
or services mentioned on this page are subject to change without notice.
** No credit card orders
Availability:
MathTensor is available in 1/4" tape (QIC-24) tar format, MS-DOS 3.5" floppies,
Macintosh 800K floppies, and Sun 3.5" bar format floppies. Other formats
will be made available as needed but may require more time for shipment.
Copy Protection:
MathTensor, like Mathematica, requires a password on UNIX machines. This
password must be obtained from MathSolutions, Inc.
Authors:
Leonard Parker, Ph.D. and Steven M. Christensen, Ph.D.,
founders of MathSolutions, Inc.
----------------------- Machine Definitions -----------------------
Microcomputers:
Macintosh
386/486 MS-DOS
386/486 Windows 3.0 or greater
Workstations: (contact MathSolutions for new machine questions)
386 Unix
Data General (AViiON)
DEC (VAXstation II, 2000, 3100, 3200, 3520, 3540;
MicroVAX II, 2000; VAX11/730; VAX11/750, 11/780, 11/785;
MicroVAX 3300, 3400; VAX 4000, 8200, 8250, 8300, 8350;
MicroVAX 3500, 3600, 3800, 3900; DECstation 2100, 3100; DECstation 5000)
Hewlett-Packard/Apollo (9000 Series 300, 9000 Series 400; 9000 Series 800-835;
Domain 2500-4500)
IBM RISC System/6000 (Powerstation 320, 520, 530, 730;
Powerserver 320, 520, 530)
MIPS (RS2030, Magnum 3000, RC2030),
NeXT (all models)
Silicon Graphics (Personal IRIS 4D/20-35, Personal IRIS 4D/85, 4D/210-220)
Sony NEWS (all models)
Sun (Sun-3, Sun 386i, SLC, IPC, Sun-4 (all models), SPARCstation 1, 1+ , 2,
SPARCserver 2)
Servers/Multi-Processor:
Convex (C1, C2)
Data General (Multi-processor AViiON)
DEC (VAX 6210, 6220, 6310, 6320, 64X0, 65X0, 8530, 8550, 8600, 8650,
8700, 8810; VAX 6230, 6240, 6330, 6340, 6350, 8800, 8820;
VAX 6360, 8830, 8840, 9000; DECsystem 3100, 5000, 5400, 5500, 5800)
Hewlett-Packard/Apollo (9000 Series 840-850, 9000 Series 855-870/200;
Series 10000), IBM RISC System/600 (Powerserver 540, 930)
MIPS (RS3240, RC3260, M/2000, RC6280)
Silicon Graphics (Power Series 4D/240-280),
Sun (SPARCstation 330, 470, SPARCserver 330, 470, 490, all MP machines)
Some of the users of MathTensor can be found at:
Wake Forest University
The University of Maryland
Insituto de Fisica Fundamental - Madrid, Spain
City College of New York
The University of Winnipeg - Canada
Stanford University
Caltech
The University of California - Santa Barbara
Texas A&M University
The University of North Carolina - Chapel Hill
Universitat Konstanz - Germany
Schlumberger KK - Japan
Sumitomo Corporation - Japan
Oakland University
Louisiana Tech University
Polaroid
Lawrence Livermore Labs
Los Alamos Labs
The University of New Brunswick - Canada
United Technologies Research Center
Universitat Hannover - Germany
Reed College
Yale University
The University of Bergen - Norway
Cotton, Inc.
NASA - Langley
NASA - Goddard
National Center for Supercomputing Applications
Wolfram Research
The University of Wisconsin - Milwaukee
The Hebrew University of Jerusalem - Israel
Martin Marietta
Cornell University
Central Connecticut State University
Universite de Liege - Belgium
Pune University - India
Cal State University - Fullerton
Utah State University
Southwestern University - Texas
University of South Florida
Deutsches Klimarenzentrum - Hamburg, Germany
University of Oklahoma - Norman
Montana State University
University of Chicago
University of Milan - Italy
Wellesley College
University of San Francisco
University of Cologne - Germany
University of California - San Diego
University of Berne - Switzerland
University d. Bundeswehr - Hamburg, Germany
University of Thessaloniki - Greece
MathTensor has been mentioned in articles in MacWorld, InfoWorld, the
Mathematica Journal, Computers In Physics, Science, and PC Magazine.
"The idea of packages and special tools has been taken to
a kind of modern limit in the form of MathTensor, a tensor-
analysis package built on Mathematica." - Richard Crandall,
Howard Vollum Professor of Science, Reed College and Chief Scientist,
NeXT Computer, Inc., from Computers in Physics, Nov/Dec 1991.
"I would like to take this opportunity to tell you how pleased
I have been with MathTensor. I have been using it to study
higher-dimensional cosmological solutions of Einstein's Equations.
It has been an indispensable tool for me. You have done a great
job." - Dwight Vincent, University of Winnipeg - Canada, Feb 1992.
"Regarding my comments on MathTensor, you can be assured that they were
coming out of my heart, and that they are TRUE. Yes, it is a very nice and
useful tool. Many people, like myself, who are getting older and loosing the
patience (and in some cases the ability to do long tedious computations) to
deal with the "nitty gritty" of things can find here REAL HELP. Also, for those of us who are daring and curious it opens up a door to tackle problems that
we otherwise wouldn't." Juan Perez Mercader, Insituto de Fisica Fundamental -
Madrid, Spain, Feb 1992.
-----------------------General Information--------------------------
MathTensor
Tensor analysis is extensively used in applications in physics,
mathematics, engineering, and many other areas of scientific research.
Problems involving tensors often are extraordinarily large and can be
some of the most difficult computations in all of science. Equations
with thousands of terms are common and can only be manipulated by
computer mathematics systems like Mathematica.
MathTensor is the largest Mathematica package yet developed outside of
Wolfram Research. It adds over 250 new functions and objects to
Mathematica to give the user both elementary and advanced tensor
analysis functionality. MathTensor is a general tool for handling both
indicial and concrete tensor indices. Standard objects like Riemann
tensor, Ricci tensor, metric and others are built into the system along
with common functions like the covariant derivative, index commutation,
raising and lowering of indices, and various differential forms
operations.
MathTensor has been under development by Leonard Parker and Steven M.
Christensen since the first alpha test release of Mathematica. It
contains over 25,000 lines of Mathematica code contained in nearly 100
files totalling approximately 2.0 Megabytes of disk space. MathTensor
will run on any machine that runs Mathematica and has sufficient RAM
memory (generally 8 Megabytes or more) and disk space for file storage
and swap. MathTensor runs under versions 1.2 and 2.0 or greater of Mathematica.
MathSolutions is in constant contact with Wolfram Research regarding
Mathematica changes and versions.
Included in this mailing are a price list, machine list, a list of the
current functions and objects, and a set of example MathTensor
computations. For other information, contact us at the address above.
MathSolutions, Inc. was formed by Leonard Parker and Steven M.
Christensen. MathSolutions has its office in Chapel Hill, North
Carolina. Both Parker and Christensen are theoretical physicists,
specializing in research in Einstein's Special and General Theory of
Relativity, quantum field theory, black hole theory, and cosmology.
Parker obtained his Ph.D. in Physics from Harvard University and
Christensen his Ph.D. in Physics from the University of Texas at Austin.
MathTensor is a trademark of MathSolutions, Inc. Mathematica is a
registered trademark of Wolfram Research, Inc.
----------------------MathTensor Examples ----------------------------
MathTensor provides commands for simplifying and manipulating tensor
expressions, as well as a knowledge base of transformation rules and
definitions required for dealing with some of the more important tensors.
MathTensor is designed to work along with the functions of Mathematica
to provide users with the functions and objects they need to devise
their own custom tensor analysis programs. MathTensor provides most
of the basic structures needed for doing tensor computations and for
programming new functions. As MathTensor is used and special applications
are developed, they will be added to future versions of MathTensor.
The following pages give a few examples of how MathTensor works.
(* First, after starting Mathematica 2.0, we load a file which
in turn loads many other files containing the MathTensor function
and object definitions. *)
In[1]:= <<MathTensor.m
====================================================
MathTensor (TM) 2.1 (UNIX (R)) (April 20, 1992)
by Leonard Parker and Steven M. Christensen
Copyright (c) 1991, MathSolutions, Inc.
Runs with Mathematica (R) Versions 1.2, 2.0 or 2.1.
Licensed to machine sunny.
====================================================
No unit system is chosen. If you want one,
you must edit the file called Conventions.m,
or enter a command to interactively set units.
Units: {}
Sign conventions: Rmsign = 1 Rcsign = 1
MetricgSign = 1 DetgSign = -1
TensorForm turned on,
ShowTime turned off,
MetricgFlag = True.
=========================================
(* MathTensor has a number of tensors already
defined. Lower indices are entered with an "l" in
front, while upper indices are entered with a "u"
in front. In output lines the indices are placed where
they should be on the tensor. *)
In[2]:= RiemannR[la,lb,lc,ld]
Out[2]= R
abcd
In[3]:= RiemannR[la,ub,lc,ud]
b d
Out[3]= R
a c
(* Operations like covariant differentiation are done simply
with the CD function, with the derivative index placed after
the tensor. *)
In[4]:= CD[RicciR[la,lb],uc]
c
Out[4]= R
ab;
(* The standard summation convention is recognized. Here
indices are summed using the standard Mathematica substitution
operation which in the case below simply renames the upper index. *)
In[5]:= % /. uc->ub
b
Out[5]= R
ab;
(* The DefineTensor function permits you to define your own
tensors. The input name of the object defined below is "tensor", and
its print name, which appears in output lines, is "t". The last argument
indicates that it will have two indices, which upon interchange result
in multiplication of the object by a weight factor of 1 -- that is,
it is a symmetric tensor. *)
In[6]:= DefineTensor[tensor,"t",{{2,1},1}]
PermWeight::sym: Symmetries of t assigned
PermWeight::def: Object t defined
In[7]:= tensor[la,lb]
Out[7]= t
ab
(* MathTensor now automatically reorders symmetric
indices into lexical order. *)
In[8]:= tensor[lb,la]
Out[8]= t
ab
(* The standard symmetries of the Riemann tensor are built into
its definition. *)
In[9]:= RiemannR[lb,la,lc,ld]
Out[9]= -R
abcd
In[10]:= RiemannR[lc,ld,la,lb]
Out[10]= R
abcd
(* MathTensor knows that the appropriate sum of indices on the
Riemann tensor gives the Ricci tensor. *)
In[11]:= RiemannR[la,lb,ua,lc]
Out[11]= R
bc
(* The sum of the indices on the Ricci tensor gives the Riemann
Scalar. *)
In[12]:= RicciR[la,ua]
Out[12]= R
(* Now we define a new tensor with four indices and no symmetries. *)
In[13]:= DefineTensor[T,"T",{{1,2,3,4},1}]
PermWeight::sym: Symmetries of T assigned
PermWeight::def: Object T defined
(* We produce a complicated product of seven of these tensor with multiple
summations of indices and then add it to another similar object. *)
In[14]:= SevenTensorTest := T[la,lb,uc,ud] T[lc,ld,ue,uf] T[le,lf,ug,uh]
T[lg,li,ui,uj] * T[lh,lj,uk,ul] T[lk,ll,um,un] T[lm,ln,ua,ub] -
T[la,lb,uc,ud] T[lc,le,ue,uf] * T[ld,lf,ug,uh] T[lg,lh,ui,uj] T[li,lj,uk,ul]
T[lk,ll,um,un] T[lm,ln,ua,ub]
(* Trying to find some simplification of SevenTensorTest is not
easy by hand. *)
In[15]:= SevenTensorTest
cd ef gh ij kl mn ab
Out[15]= T T T T T T T -
ab cd ef gi hj kl mn
cd ef gh ij kl mn ab
> T T T T T T T
ab ce df gh ij kl mn
(* But the MathTensor command Tsimplify rapidly finds that the two terms are
equal. *)
In[16]:= Tsimplify[%]
Out[16]= 0
(* Some terms differ only by the renaming of summation indices. *)
In[17]:= T[la,lb,lc,ld] RiemannR[ua,ub,uc,ud] +
T[le,lf,lg,lh] RiemannR[ue,uf,ug,uh]
abcd efgh
Out[17]= R T + R T
abcd efgh
(* MathTensor's canonicalization functions can rename indices and
combine terms. *)
In[18]:= Canonicalize[%]
pqrs
Out[18]= 2 R T
pqrs
(* MathTensor can symmetrize or antisymmetrize pairs of indices. *)
In[19]:= Symmetrize[T[la,lb,lc,ld], {la,lb}]
T + T
abcd bacd
Out[19]= -------------
2
In[20]:= Expand[%]
T T
abcd bacd
Out[20]= ----- + -----
2 2
In[21]:= Antisymmetrize[%,{lc,ld}]
T T T T
abcd abdc bacd badc
----- - ----- + ----- - -----
2 2 2 2
Out[21]= -----------------------------
2
In[22]:= Expand[%]
T T T T
abcd abdc bacd badc
Out[22]= ----- - ----- + ----- - -----
4 4 4 4
(* MathTensor understands how to convert covariant to ordinary
partial derivatives with affine connection terms added. *)
In[23]:= CD[RicciR[la,lb],lc]
Out[23]= R
ab;c
In[24]:= CDtoOD[%]
p p
Out[24]= R - G R - G R
ab,c bc pa ac pb
(* Using positive and negative index values, MathTensor can
deal with concrete contravariant or covariant indices. *)
In[25]:= RiemannR[1,2,3,4]
1234
Out[25]= R
In[26]:= RiemannR[-1,2,-3,4]
4 2
Out[26]= R
3 1
(* We can set the dimension of the spacetime to some value, like 4. *)
In[27]:= Dimension = 4
Out[27]= 4
(* Then using the MakeSum function, we can explicitly write out
sums in terms of concrete indices. *)
In[28]:= MakeSum[RicciR[la,lb] RicciR[lc,ub]]
1 2 3 4
Out[28]= R R + R R + R R + R R
1a c 2a c 3a c 4a c
(* Now we define tensor T with two indices that are symmetric. *)
In[29]:= DefineTensor[T,"T",{{2,1},1}]
PermWeight::sym: Symmetries of T assigned
PermWeight::def: Object T defined
(* Then the lower components of T can be defined in terms of
the components of other tensors like the Ricci tensor. *)
In[30]:= SetComponents[T[la,lb],RicciR[la,lc] RicciR[lb,uc]]
Components assigned to T
(* We can ask for a specific covariant component of T. *)
In[31]:= T[-1,-1]
1 2 3 4
Out[31]= R R + R R + R R + R R
11 1 21 1 31 1 41 1
(* One example application built into MathTensor does variations
with respect to the metric tensor of structures that are functions
of the metric tensor, Metricg. The variation of the square root
of the determinant of the metric times the Riemann scalar gives
terms in the variation of the metric, called h. *)
In[32]:= Sqrt[Detg] ScalarR
Out[32]= Sqrt[g] R
In[33]:= Variation[%,Metricg]
MetricgFlag::off:
MetricgFlag is turned off by this operation
pq p q
Out33]= Sqrt[g] h - Sqrt[g] h +
pq; p ;q
pq
Sqrt[g] R g h
pq pq
----------------- - Sqrt[g] R h
2 pq
(* A more complicated variation is just as easily found. *)
In[34]:= Sqrt[Detg] RicciR[la,lb] RicciR[ua,ub]
ab
Out[34]= Sqrt[g] R R
ab
In[35]:= Variation[%,Metricg]
pq r
-(Sqrt[g] h R )
;r pq p rq
Out[35]= --------------------- + Sqrt[g] h R -
2 q; pr
p qr r pq
Sqrt[g] h R Sqrt[g] h R
p ; qr pq;r
------------------ - ------------------ +
2 2
p qr
Sqrt[g] h R
q pr p ;qr
Sqrt[g] h R - ------------------ +
pq;r 2
pq rs
Sqrt[g] g R R h
rs pq qr p
----------------------- - Sqrt[g] R R h -
2 pq r
pr q
Sqrt[g] R R h
pq r
(* MathTensor's ApplyRules function permits the user to define large
sets of rules that can be applied to expressions to simplify them.
One set of rules that is provided as an example are the RiemannRules.
Familiar rules are applied in the next two examples. MathTensor includes
several functions DefUnique and RuleUnique that help the user devise
their own rules and save them for later use. *)
In[36]:= CD[RicciR[la,lb],ub]
b
Out[36]= R
ab;
In[37]:= ApplyRules[%,RiemannRules]
R
;a
Out[37]= ---
2
In[38]:= RiemannR[la,lb,lc,ld] RiemannR[ua,uc,ub,ud]
acbd
Out[38]= R R
abcd
In[39]:= ApplyRules[%,RiemannRules]
pqrs
R R
pqrs
Out[39]= -----------
2
(* Suppose we define a tensor with four indices. *)
In[40]:= DefineTensor[tensor,"t",{{1,2,3,4},1}]
PermWeight::sym: Symmetries of t assigned
PermWeight::def: Object t defined
(* MathTensor's multiple index facility permits the user to
add indices with one, two or three primes to be used as
extra non-spacetime indices. *)
In[41]:= AddIndexTypes
In[42]:= tensor[ala,blb,clc,ld]
Out[42]= t
a'b''c'''d
(* Tools for building rules involving these extra indices are
provided. Future releases of MathTensor will extend this
functionality. *)
(* Shipped with MathTensor is the file Components.m which may be
run separately from MathTensor. Components.m takes a file like
CompInSchw.m, listed next, and computes the components of the affine
connection, the Riemann tensor, Ricci tensor, Riemann scalar, Weyl
tensor, Einstein tensor and several other objects. CompInSchw.m
is the input file containing information about the famous Schwarzschild
metric. This metric represents the curved space of a gravitating
spherically symmetric object with mass M in otherwise empty space. *)
---------------------- CompInSchw.m file listing --------------------
(*
CompInSchw.m , sample input file for Components. This contains the
Schwarzschild exterior solution of the vacuum Einstein equations.
The convention is that negative integers from -Dimension to -1
denote covariant index values, and positive integers from 1 to
Dimension denote contravariant index values. The value 0 is not
used for an index value because its sign can not be used to
distinguish between a covariant and contravariant index.
*)
(* Give the value of Dimension, in this case the value is 4 *)
Dimension = 4
(* Give the names of the coordinates x[1],..,x[Dimension] *)
x/: x[1] = r
x/: x[2] = theta
x/: x[3] = phi
x/: x[4] = t
(*
Give the covariant components of the metric tensor. Negative integers
denote covariant components. Since Metricg is symmetric, only the
components with ordered indices should be specified. Note that -3, for
example, is lexically before -1, so Metricg[-3,-1] is specified and not
Metricg[-1,-3]. All components having the first index less than or equal
to the second index, up to Metricg[-Dimension, -Dimension], should be
specified.
*)
Metricg/: Metricg[-1, -1] = (1 - (2*G*M)/r)^(-1)
Metricg/: Metricg[-2, -1] = 0
Metricg/: Metricg[-3, -1] = 0
Metricg/: Metricg[-4, -1] = 0
Metricg/: Metricg[-2, -2] = r^2
Metricg/: Metricg[-3, -2] = 0
Metricg/: Metricg[-4, -2] = 0
Metricg/: Metricg[-3, -3] = r^2*Sin[theta]^2
Metricg/: Metricg[-4, -3] = 0
Metricg/: Metricg[-4, -4] = -(1 - (2*G*M)/r)
(* Next give the flag settings for various options explained below. *)
Rmsign = 1
Rcsign = 1
CalcEinstein = 1 (* Calculate the covariant Einstein tensor components
EinsteinG[la,lb]. The value 0 tells Components not
to calculate these components.
*)
CalcRiemann = 1 (* Calculate the covariant Riemann tensor components
RiemannR[la,lb]. The value 0 tells Components not
to calculate these components.
*)
CalcWeyl = 1 (* Calculate the covariant Weyl tensor components
WeylC[la,lb]. The value 0 tells Components not
to calculate these components.
*)
Perturb[,]
(* End of file CompInSchw.m *)
---------------------------------------------------------------------
(* If we load Components.m into Mathematica we can run the following
command to produce from CompInSchw.m two new files, CompOutSchw.m, which
contains results that can be used immediately in MathTensor, and
CompOutSchw.out which can be printed. The computation below takes
from just a few seconds to less than one minute on typical workstations.
More complex metrics can take a bit longer. *)
In[1]:= <<Components.m
====================================================
MathTensor (TM) 2.1 (UNIX (R)) (April 20, 1992)
Components Package
by Leonard Parker and Steven M. Christensen
Copyright (c) 1991, MathSolutions, Inc.
Runs with Mathematica (R) Versions 1.2, 2.0 and 2.1.
Licensed to machine sunny.
====================================================
In[2]:= Components["CompInSchw.m","CompOutSchw.m", "CompOutSchw.out"]
The following tensors have been calculated and stored
in the file CompOutSchw.m in InputForm, and
in the file CompOutSchw.out in OutputForm:
Metricg
MatrixMetricgLower
MatrixMetricgUpper
Detg
AffineG[ua,lb,lc]
RicciR[la,lb]
ScalarR
EinsteinG[la,lb,lc,ld]
RiemannR[la,lb,lc,ld]
WeylC[la,lb,lc,ld]
You can edit CompOutSchw.out to print a record of the results.
(* The listing of the output file is too long to give here, but it
gives the calculated values of the components of the Riemann and
related tensors in the Schwarzschild spacetime. *)
The names of the various commands and other objects available in
MathTensor is given below:
A List of MathTensor Functions and Objects (12/15/91)
Absorb Epsilon InvertFast
Absorbg EpsilonProductTensor Kdelta
AbsorbKdelta EpsilonProductTensorRule KdeltaRule
AbsorbRule EpsilonSign Kill
AddIndexTypes EpsilonToEpsDownRule Lap
AffineG EpsilonToEpsUpRule LieD
AffineToMetric EpsUp LieDtoCD
AffineToMetricRule EpsUpToEpsDownRule LieDtoCDrule
AllSymmetries EpsUpToEpsilonRule Lightc
Antisymmetrize EqApart LorentzGaugeRule
ApplyRules EqApply Lower
ApplyRulesRepeated EqCancel Lowera
Arglist EqCollect LowerAllPairs
ArglistAllTypes EqDivide LowerAllTypes
AskSignsFlag EqExpand Lowerb
AskSignsProcedure EqExpandAll Lowerc
BianchiFirstPairRule EqFactor LowerIndexAllTypesQ
BianchiSecondPairRule EqFactorTerms LowerIndexaQ
CanAll EqMinus LowerIndexbQ
CanApplyRules EqPlus LowerIndexcQ
CanApplyRulesFast EqPower LowerIndexQ
CanApplyRulesRepeated EqReverse MakeAllSymmetries
CanDum EqSimplify MakePermWeightGroup
Cannn EqSolve MakeSum
CannnDum EqSubtract Matchlist
CanNonInvert EqTimes Matchlista
Canonicalize EqTogether MatchlistAllTypes
CanSame EqTwoDivide Matchlistb
CanSuperApplyRules EqTwoPlus Matchlistc
CD EqTwoSubtract MatchlistOrd
CDtoOD EqTwoTimes $MathTensorVersionNumber
ClearComponents esuUnits MaxwellA
ClearUnits EvaluateODFlag MaxwellB
CommuteCD Evenlist MaxwellCyclicEquation
Components Explode MaxwellCyclicRule
CountNewDums FirstCubicRiemannRule MaxwellDivergenceEquation
CoXD FirstQuadraticRiemannRule MaxwellDivergenceRule
DefineForm FreeList MaxwellE
DefineTensor FtoC MaxwellF
DefUnique FtoCrule MaxwellJ
Detg GaussianUnits Maxwellk1
DetgSign GenLap Maxwellk3
Dimension GravitationalUnits Maxwellrho
Downdummylist hbar MaxwellT
Downlist HeavisideLorentzUnits MaxwellTexpression
Downuserlist HodgeStar MaxwellTtoFrule
DualStar Implode MaxwellVectorPotentialRule
Dum IndexAllTypesQ Metricg
DumAllTypes IndexaQ MetricgFlag
EinsteinG IndexbQ MetricgFlagOff
EinsteinToRicciRule IndexcQ MetricgFlagOn
emuUnits IndexQ MetricgSign
Eps0 IndexTypes Mu0
EpsDown IndicesAndNotOrderedQ NaturalUnits
EpsDownToEpsilonRule InListQ NegIntegerQ
EpsDownToEpsUpRule Invert NewtonG
NonTensorPart Symmetries
OD SymmetriesOfSymbol
Oddlist Symmetrize
OrderedArgsQ SyntaxCheck
Pair SyntaxCheckOff
PairAllTypes SyntaxCheckOn
PairAllTypesQ TensorForm
PairaQ TensorPart
PairbQ TensorPartSameQ
PaircQ TensorQ
Pairdum TensorSimp
PairQ TensorSimpAfter
PermWeight TraceFreeRicciR
PIntegrate TraceFreeRicciToRicciRule
PosIntegerQ Tsimplify
PrettyOff TsimplifyAfter
PrettyOn Units
Raise Unlist
Raisea Updowndummylist
RaiseAllTypes Updummylist
Raiseb Uplist
Raisec UpLo
RankForm UpLoa
RationalizedGaussianUnit UpLob
RationalizedMKSUnits UpLoc
Rcsign UpperIndexAllTypesQ
RicciR UpperIndexaQ
RicciSquared UpperIndexbQ
RicciToAffine UpperIndexcQ
RicciToAffineRule UpperIndexQ
RicciToTraceFreeRicciRule Upuserlist
RiemannCyclicFirstThreeRule Var
RiemannCyclicSecondThreeRule Varg
RiemannR Variation
RiemannRules VariationalDerivative
RiemannSquared VectorA
RiemannToAffine VectorAFlag
RiemannToAffineRule WeylC
RiemannToWeylRule WeylToRiemannRule
Rmsign XD
Rulelists XDtoCDflag
RuleUnique XP
RuleUniqueAllTypes ZeroFormQ
ScalarR
ScalarRtoAffine
ScalarRtoAffineRule
SecondCubicRiemannRule
SecondQuadraticRiemannRule
SetAntisymmetric
SetComponents
SetSymmetric
ShowNumbers
ShowTime
SIUnits
SuperApplyRules
SwapDum
Prev by Date:
**minor revision of histogram.m**
Next by Date:
**skyline method**
Previous by thread:
**minor revision of histogram.m**
Next by thread:
**skyline method**
| |