Mathematica

Mathematica
-------------------------------------------------------------------- Mathematica Mathematica

--------------------------------------------------------------------Mathematica --

Line1; Line
Line1,line2 Line12
?name name
??name name
!command Dos
n! N
!!filename
<
Expr>> filename
Expr>>>filename
()
[]
{}
c math
(*Note*)
#n n
##
rule& rule
%
%%
%n n
var::note var
"Astring "
Context `
a+b
a-b

a*b a b
a/b
a^b

a^b
base^^num base
lhs&&rhs
lhs||rhs
!lha
++,-- 1 1
+=,-=,*=,/= C
>,=,<=,==,!= c
lhs=rhs
lhs:=rhs
lhs:>rhs
lhs->rhs
expr//funname filename[expr]
expr/.rule rule expr
expr//.rule rule expr
param_ param
param__ param
- :BBS bbs.net.tsinghua.edu.cn[FROM: 202.115.11.164]

Mathematica

: FangQ (), : MathTools

: Mathematica
: BBS (Wed Nov 18 21:35:33 1998)
Mathematica

Pi 3.1415....
E 2.17828...
Catalan 0.915966..
EulerGamma 0.5772....
GoldenRatio 1.61803...
Degree Pi/180
I
Infinity
-Infinity
ComplexInfinity
Indeterminate

Expand[expr]
Factor[expr]
Simplify[expr]
FullSimplify[expr]
PowerExpand[expr]
ComplexExpand[expr,{x1,x2...}]
FunctionExpand[expr] expr
Collect[expr, x]
Collect[expr, {x1,x2,...}] x1,x2,...
Together[expr]
Apart[expr]
Apart[expr, var] var
Cancel[expr]
ExpandAll[expr]
ExpandAll[expr, patt]
FactorTerms[poly]
FactorTerms[poly, x] x
FactorTerms[poly, {x1,x2...}] xi
Coefficient[expr, form] expr form
Coefficient[expr, form, n] expr form^n

Exponent[expr, form] expr form

Numerator[expr] expr
Denominator[expr] expr
ExpandNumerator[expr] expr
ExpandDenominator[expr] expr
ExpandDenominator[expr] expr
TrigExpand[expr]
TrigFactor[expr]
TrigFactorList[expr]
TrigReduce[expr]
TrigToExp[expr]
ExpToTrig[expr]
RootReduce[expr]
ToRadicals[expr]
- :BBS bbs.net.tsinghua.edu.cn[FROM:
202.115.11.164]

Mathematica

: FangQ (), : MathTools

: Mathematica
: BBS (Wed Nov 18 21:35:55 1998)
Mathematica

Solve[eqns, vars] eqns vars

Solve[eqns, vars, elims] eqns elims, vars
DSolve[eqn, y, x] y x
DSolve[{eqn1,eqn2,...},{y1,y2...},x] yi x
DSolve[eqn, y, {x1,x2...}]
Eliminate[eqns, vars] eqns vars
SolveAlways[eqns, vars]
Reduce[eqns, vars]
LogicalExpand[expr] &&||
InverseFunction[f] f
Root[f, k] k
Roots[lhs==rhs, var]

D[f, x] f[x]
D[f, {x, n}] f[x] n
D[f,x1,x2..] f[x] x1,x2...
Dt[f, x] f[x] df/dx
Dt[f] f[x] df
Dt[f, {x, n}] n df^n/dx^n
Dt[f,x1,x2..] x1,x2..
Integrate[f, x] f[x] x
Integrate[f, {x, xmin, xmax}] f[x] x (xmin,xmax)
Integrate[f, {x, xmin, xmax}, {y, ymin, ymax}] f[x,y]
Limit[expr, x->x0] x x0 expr
Residue[expr, {x,x0}] expr x0
Series[f, {x, x0, n}] f[x] x0
Series[f, {x, x0,nx}, {y, y0, ny}] y x
Normal[expr]
SeriesCoefficient[series, n] n
SeriesCoefficient[series, {n1,n2...}]
' Derivative[n1,n2...][f]

InverseSeries[s, x]
ComposeSeries[serie1,serie2...]
SeriesData[x,x0,{a0,a1,..},nmin,nmax,den] x0 x
aii
O[x]^n n x^n
O[x, x0]^n n (x-x0)^n
Dt[f, x] f[x] df/dx
Dt[f] f[x] df
Dt[f, {x, n}] n df^n/dx^n
Dt[f,x1,x2..] x1,x2..
Integrate[f, x] f[x] x
Integrate[f, {x, xmin, xmax}] f[x] x (xmin,xmax)
Integrate[f, {x, xmin, xmax}, {y, ymin, ymax}] f[x,y]
Limit[expr, x->x0] x x0 expr
Residue[expr, {x,x0}] expr x0
Series[f, {x, x0, n}] f[x] x0
Series[f, {x, x0,nx}, {y, y0, ny}] y x
Normal[expr]
SeriesCoefficient[series, n] n
SeriesCoefficient[series, {n1,n2...}]
' Derivative[n1,n2...][f]
InverseSeries[s, x]
ComposeSeries[serie1,serie2...]
SeriesData[x,x0,{a0,a1,..},nmin,nmax,den] x0 x
ai
O[x]^n n x^n
O[x, x0]^n n (x-x0)^n
- :BBS bbs.net.tsinghua.edu.cn[FROM:
202.115.11.164]

Mathematica

: FangQ (), : MathTools

: Mathematica ()
: BBS (Thu Nov 19 18:02:49 1998)
Mathematica ()

Variables[poly] poly
CoefficientList[poly, var] poly var

CoefficientList[poly, {var1,var2...}] poly

var(i)?
PolynomialMod[poly, m] poly mod m
m
PolynomialQuotient[p, q, x] x
p/q
PolynomialRemainder[p, q, x] x

PolynomialGCD[poly1,poly2,...] poly(i)
PolynomialLCM[poly1,poly2,...] poly(i)
PolynomialReduce[poly, {poly1,poly2,...},{x1,x2...}]
{{a1,a2,...},b} Sum[ai*polyi]+b=poly
Resultant[poly1,poly2,var] poly1,poly2 var
Factor[poly]
FactorTerms[poly] poly
FactorTerms[poly, {x1,x2...}] poly xi

FactorList[poly]
poly {{poly1,exp1},{...}...}
FactorSquareFreeList[poly]
FactorTermsList[poly,{x1,x2...}]

xi xi
?
Cyclotomic[n, x] n
Decompose[poly, x] {p1,p2,...},
p1(p2(...))=poly
InterpolatingPolynomial[data, var] data

data {f1,f2..}{{x1=1,y1=f1}..}
data {{x1,f1,df11,df12,..},{x2,f2,df21..}
n
RootSum[f, form] f[x]=0
Sum[form[xi]]

Random[type,range] type range

type Integer,Real,Complex, Real

range {min,max}{0,1}
Random[] 01
SeedRandom[n] n seed
<
2.0
<<"D:\\Math\\PACKAGES\\STATISTI\\Continuo.m"
Random[distribution]
Random[BetaDistribution[alpha, beta]]
stribution[alpha, beta]]
Random[NormalDistribution[miu,sigma]]

BetaDistribution,CauchyDistribution,ChiDistribution,
NoncentralChiSquareDistribution,ExponentialDistribution
,
ExtremeValueDistribution,NoncentralFRatioDistribution,
GammaDistribution,HalfNormalDistribution,
LaplaceDistribution,
LogNormalDistribution,LogisticDistribution,
RayleighDistribution,NoncentralStudentTDistribution,
UniformDistribution, WeibullDistribution
- :BBS bbs.net.tsinghua.edu.cn[FROM:
202.115.11.164]


Mathematica

: FangQ (), :
MathTools
: Mathematica
: BBS (Fri Nov 20 21:39:10
1998)
Mathematica

N[expr]
N[expr, n] n n
NSolve[lhs==rhs, var]
NSolve[eqn, var, n] n

NDSolve[eqns, y, {x, xmin, xmax}]

NDSolve[eqns, {y1,y2,...}, {x, xmin, xmax}]

FindRoot[lhs==rhs, {x,x0}] x0

FindRoot[lhs==rhs, {x, xstart, xmin, xmax}]

NSum[f, {i,imin,imax,di}] di
NSum[f, {i,imin,imax,di}, {j,..},..]

NProduct[f, {i, imin, imax, di}]

NIntegrate[f, {x, xmin, xmax}]

FindMinimum[f, {x,x0}] x0

FindMinimum[f, {x, xstart, xmin, xmax}]

ConstrainedMin[f,{inequ},{x,y,..}]
inequ f x,y..

 x,y..
ConstrainedMax[f, {inequ}, {x, y,..}]
LinearProgramming[c,m,b] c.x
m.x>=b&&x>=0
x,b,c ,m
LatticeReduce[{v1,v2...}] vi

Fit[data,funs,vars]

data {{x1,y1,..f1},{x2,y2,..f2}..}

emp: Fit[{10.22,12,3.2,9.9}, {1, x,

x^2,Sin[x]}, x]
Interpolation[data],
data
{{x1,{f1,df11,df12}},{x2,{f2,.}..}
InterpolationOrder 3
ListInterpolation[array]array
n
ListInterpolation[array,{{xmin,xmax},{ymin,yma
x},..}]
FunctionInterpolation[expr,{x,xmin,xmax},
{y,ymin,ymax},..]
expr[xi,yi]
Fourier[list]
InverseFourier[list]
Min[{x1,x2...},{y1,y2,...}]

Min[{x1,x2...},{y1,y2,...}]

Max[{x1,x2...},{y1,y2,...}]

Select[list, crit] crit True

Count[list, pattern] pattern

Sort[list]
Sort[list,p] p[e1,e2] True
list
e1,e2, Sort[list]
p=Greater


Union[list1,list2..] listi
Intersection[list1,list2..] listi

Complement[listall,list1,list2...]
listall listi
- :BBS
bbs.net.tsinghua.edu.cn[FROM:
202.115.11.164]

Mathematica

: FangQ (), : MathTools

: Mathematica
: BBS (Mon Nov 23 08:20:15 1998)
Mathematica

Re[expr]
Im[expr]
Abs[expr]
Arg[expr]
Conjugate[expr]

Integer _Integer
Real _Real
Complex _Complex
Rational_Rational
(* MyFun[Para1_Integer,Para2_Real]
If[Head[a]==Real,...]*)
IntegerDigits[n,b,len] n b len
RealDigits[x,b,len]
FromDigits[list] IntegerDigits
Rationalize[x,dx] x dx
Chop[expr, delta] expr delta ,dx 10^-10
Accuracy[x] x , Pi,E
Precision[x] x , Pi,E
SetAccuracy[expr, n] expr
SetPrecision[expr, n] expr

Interval[{min, max}] [min, max](* Solve[3 x+2==Interval[{2,5}],xx]*)

IntervalMemberQ[interval, x] x
IntervalMemberQ[interval1,interval2] 2 1
IntervalUnion[intv1,intv2...]
IntervalIntersection[intv1,intv2...]

a.b.c Dot[a, b, c]

Inverse[m]
Transpose[list]
Transpose[list,{n1,n2..}] list k nk
Det[m]
Eigenvalues[m]
Eigenvectors[m]

Eigenvectors[m]
Eigensystem[m] {eigvalues,eigvectors}
LinearSolve[m, b] m.x==b
NullSpace[m] m m.NullSpace[m]==
RowReduce[m] m
Minors[m, k] m k*k ()
MatrixPower[mat, n] mat n
Outer[f,list1,list2..] listi f
?
Outer[Times,list1,list2]
SingularValues[m] m {u,w,v},
m=Conjugate[Transpose[u]].DiagonalMatrix[w].v
PseudoInverse[m] m
QRDecomposition[m] QR
SchurDecomposition[m] Schur
LUDecomposition[m] LU

- :BBS bbs.net.tsinghua.edu.cn[FROM:
202.115.11.164]

Mathematica

: FangQ (), : MathTools

: Mathematica
: BBS (Sat Nov 28 20:14:58 1998)
Mathematica

(* Mathematica *)
(* list==expr
*)
(* *)

{e1,e2,...}
Table[expr,{imax}] imax
Table[expr,{i, imax}] imax expr[i]
Table[expr,{i,imin,imax},{j,jmin,jmax},..]
Range[imax] {1,2,..,imax}
Range[imin, imax, di] di
Array[f, n] f[i] (i 1 n)
Array[f,{n1,n2..}] f[i,j..] ( 1 ni)
IdentityMatrix[n] n
DiagonalMatrix[list]

Part[expr, i] expr[[i]] i
expr[[-i]] i
expr[[i,j,..]]
expr[[{i1,i2,..}] i(n)
First[expr]
Last[expr]
Head[expr] expr[[0]]
Extract[expr, list] list expr
Take[list, n] list n
Take[list,{m,n}] list m n
Drop[list, n] list n
Rest[expr] list
Select[list, crit] crit list
True


Length[expr] expr
Dimensions[expr] {n1,n2..},expr n1*n2...

TensorRank[expr]
Depth[expr] expr
Level[expr,n] expr n
Count[list, pattern] list
MemberQ[list, form] list form
FreeQ[expr, form] MemberQ
Position[expr, pattern] pattern

Cases[{e1,e2...},pattern] pattern ei

Append[expr, elem] expr elem

Prepend[expr, elem] expr elem
Insert[list, elem, n] n elem
Insert[expr,elem,{i,j,..}] expr[[{i,j,..}]]
elem
Delete[expr, {i, j,..}] expr[[{i,j,..}]]

DeleteCases[expr,pattern] pattern

ReplacePart[expr,new,n] expr n new

Sort[list] list
Reverse[expr] expr
RotateLeft[expr, n] expr n
RotateRight[expr, n] expr n
Partition[list, n] list n

Flatten[list]
Flatten[list,n] n
Split[list]
FlattenAt[list, n] list[[n]]
FlattenAt[list, n] list[[n]]
Permutations[list] list
Order[expr1,expr2] expr1 expr2 1, expr1

expr2 -1, expr1 expr2 0

Signature[list] list
()

AppendTo[list,elem] list=Append[list,elem];
PrependTo[list,elem] list=Prepend[list,elem];
- :BBS bbs.net.tsinghua.edu.cn[FROM:
202.115.11.198]

Mathematica

: FangQ (), : MathTools

: Mathematica --
: BBS (Sat Nov 28 21:50:37 1998)
Mathematica --

Plot[f,{x,xmin,xmax}] f[x]
[xmin,xmax]?
Plot[{f1,f2..},{x,xmin,xmax}]
ListPlot[{y1,y2,..}] (n,yn)
ListPlot[{{x1,y1},{x2,y2},..}]
(xn,yn)
ParametricPlot[{fx,fy},{t,tmin,tmax}]

ParametricPlot[{{fx,fy},{gx,gy},...},{t,tmin,tmax}]

PlotRange->{0,1}
AspectRatio->1/GoldenRatio
PlotLabel ->label
Axes ->{False,True} x,y
AxesLabel->{xlabel,ylabel}x,y
Ticks->None,Automatic,fun
AxesOrigin ->{x,y}
AxesStyle->{{xstyle}, {ystyle}}

Frame ->True,False
FrameLabel ->{xmlabel,ymlabel,xplabel,yplabel}

FrameTicks Ticks
GridLines Ticks
FrameStyle ->{{xmstyle},{ymstyle}

ListPlot[data,PlotJoined->True]
PlotSytle->{{style1},{style2},..}

PlotPoints->15

Plot3D[f,{x,xmin,xmax}, {y,ymin,ymax}]
f[x,y]
Plot3D[{f,s}, {x,xmin,xmax}, {y,ymin,ymax}]
s[x,y]
ListPlot3D[array] array
ListPlot3D[array,shades]
shades[]
ParametricPlot3D[{fx,fy,fz},{t,tmin,tmax}]

ParametricPlot3D[{{fx,fy,fz},{gx,gy,gz},...},{t,tmi
n,tmax}]

ViewPoint ->{x,y,z} {1.3,-2.4,2}

Boxed -> True,False
BoxRatios->{sx,sy,sz}
BoxStyle
Lighting ->True
LightSources->{s1,s2..} si
si={{dx,dy,dz},color}
color dx,dy,dz
AmbientLight->
Mesh->True,False x,y

MeshStyle
MeshRange->{{xmin,xmax}, {ymin,ymax}}
ClipFill->Automatic,None,color,{bottom,top}

Shading ->False,True
HiddenSurface->True,False

ContourPlot[f,{x,xmin,xmax},{y,ymin,ymax}]
f[x,y]
ListContourPlot[array] array

Contours->n n

Contours->{z1,z2,..} zi
ContourShading -> False
ContourLines -> True
ContourStyle -> {{style1},{style2},..}

FrameTicks

DensityPlot[f,{x,xmin,xmax},{y,ymin,ymax}]
f[x,y]
ListDensityPlot[array]

Show[graphics,options] options

Show[g1,g2...]
GraphicsArray[{g1,g2,...}]

SelectionAnimate[notebook,t] notebook

()
>
()
Background->
RotateLabel -> True
TextStyle
ColorFunction->Hue

RenderAll->False
MaxBend

- :BBS
bbs.net.tsinghua.edu.cn[FROM: 202.115.11.198]

Mathematica

: FangQ (), : MathTools

: Mathematica --
: BBS (Sat Nov 28 21:50:59 1998)
Mathematica --

Graphics[prim, options]
prim
Graphics3D[prim, options]
prim
SurfaceGraphics[array, shades] array
shade
ContourGraphics[array] array

DensityGraphics[array] array

Point[p] p={x,y}{x,y,z}
Line[{p1,p2,..}] pi
Rectangle[{xmin, ymin}, {xmax, ymax}]
Cuboid[{xmin,ymin,zmin},{xmax,ymax,zmax}]

Polygon[{p1,p2,..}]
Circle[{x,y},r]
Circle[{x,y},{rx,ry}] rx,ry
Circle[{x,y},r,{a1,a2}] a1a2
Disk[{x, y}, r]
Raster[array,ColorFunction->f]
Text[expr,coords] coords
PostScript["string"] PostScript
Scaled[{x,y,..}] 0 1
()
GrayLevel[level] level 0~1

RGBColor[red, green, blue] RGB 0~1

Hue[h, s, b] 0~1
CMYKColor[cyan, magenta, yellow, black] CMYK
()
Thickness[r] r
PointSize[d]
Dashing[{r1,r2,..}]
ImageSize->{x, y} ()
ImageResolution->r r dpi
()
ImageResolution->r r dpi
ImageMargins->{{left,right},{bottom,top}}
ImageRotated->False 90

- :BBS
bbs.net.tsinghua.edu.cn[FROM: 202.115.11.198]

Mathematica

: FangQ (), :
MathTools
: Mathematica

: BBS (Sat Dec 12

11:42:31 1998)
Mathematica

If[condition, t, f] condition True,

t f
If[condition, t, f, u] True
False u
Which[test1,block1,test2,block2..]
True testi blocki
Switch[expr,form1,block1,form2,block2..]
expr formi
blocki

Do[expr,{imax}] expr imax

Do[expr,{i,imin,imax}, {j,jmin,jmax},...]

While[test, body] body test

False
For[start,test,incr,body] C
for""";"
examp: For[i=1;t =x,i^2

Throw[value] value
Catch
Throw[value, tag]
Catch[expr] expr, Throw

Catch[expr, form] Throw[value, tag]

Tag form

Return[expr] expr
Return[ ] Null

Break[ ]
Continue[ ]
Goto[tag] Label[Tag]
Label[tag]
Check[expr,failexpr] expr,
failexpr
Check[expr,failexpr,s1::t1,s2::t2,...]
failexpr
CheckAbort[expr,failexpr] abort
failexpr
Interrupt[ ]
Abort[ ]
TimeConstrained[expr,t] expr
t
MemoryConstrained[expr,b] expr
b

Print[expr1,expr2,...] expri
examp: Print[ "X=" , X//N , " " ,f[x+1]];
Input[ ]

Input["prompt"] prompt

Pause[n] n

Pause[n] n

-
THIS IS THE FINAL CONFLICT
:BBS
bbs.net.tsinghua.edu.cn[FROM:
202.115.15.197]

Mathematica

: FangQ (), : MathTools

: Mathematica
: BBS (Sat Dec 12 11:44:33 1998)
Mathematica

(* Mathematica
*)
(*Mathematica Mathematica
*)
(*,*)

Function[body] body&
?
Function[x, body]
Function[{x1,x2,...},body]
##n n
##
examp: #1^#2& [2,3]

Map[f,expr] f/@expr f expr

Map[f,expr,level] f expr level
Apply[f,expr] f@@expr expr f
Apply[f,expr,level] expr level f
MapAll[f,expr] f//@expr f expr
MapAt[f,expr,n] f expr n
MapAt[f,expr,{i,j,...}] f expr[[{i,j,...}]]
MapIndexed[f,expr] MapAll,
Scan[f, expr] f expr
Scan[f,expr,levelspec] level

Nest[f,expr,n] n f[f[...f[expr]...]]
NestList[f,expr,n] 0 n
{expr,f[expr],f[f[exprr]]..}
FixedPoint[f, expr] f expr ,

FixedPoint[f, expr, n] n
FixedPointList[f, expr]
FoldList[f,x,{a,b,..}] {x,f[x,a],f[f[x,a],b],..}
Fold[f, x, list] FoldList[f,x,{a,b,..}]
ComposeList[{f1,f2,..},x]{x,f1[x],f2[f1[x]],..}
Distribute[f[x1,x2,..]] f
Distribute[expr, g] g
Identity[expr] expr
Composition[f1,f2,..] f1[f2[..fn[ ]..]
Operate[p,f[x,y]] p[f][x, y]
br> Operate[p,f[x,y]] p[f][x, y]
Through[p[f1,f2][x]] p[f1[x],f2[x]]
Compile[{x1,x2,..},expr]
Compile[{{x1,t1},{x2,t2}..},expr]

lhs->rhs lhs rhs, rhs

lhs:>rhs rhs
Replace[expr,rules] expr
expr /. rules
expr //.rules rules expr
Dispatch[{lhs1->rhs1,lhs2->rhs2,...}]

-
THIS IS THE FINAL CONFLICT
:BBS bbs.net.tsinghua.edu.cn[FROM:
202.115.15.197]

Mathematica

: FangQ (), : MathTools

: Mathematica
: BBS (Sat Dec 12 11:45:43 1998)
Mathematica

(* True False*)
(* Mathematica ?*Q *)
ArgumentCountQ MatrixQ
AtomQ MemberQ
DigitQ NameQ
EllipticNomeQ NumberQ
EvenQ NumericQ
ExactNumberQ OddQ
FreeQ OptionQ
HypergeometricPFQ OrderedQ
InexactNumberQ PartitionsQ
IntegerQ PolynomialQ
IntervalMemberQ PrimeQ
InverseEllipticNomeQ SameQ
LegendreQ StringMatchQ
LetterQ StringQ
LinkConnectedQ SyntaxQ
LinkReadyQ TrueQ
ListQ UnsameQ
LowerCaseQ UpperCaseQ
MachineNumberQ ValueQ
MatchLocalNameQ VectorQ
MatchQ

"text" _String
"s1"<>"s2"<>.. StringJoin["s1","s2",..]
StringLength["string"]
StringReverse["string"]
StringTake["string", n] n Take[]
StringDrop["string", n] Drop,
StringInsert["string","snew",n] Insert[]
StringPosition["string", "sub"] sub string
StringReplace["string",{"s1"->"p1",..}]
StringReplacePart["string", "snew", {m, n}]
string m~n snew
string m~n snew
StringToStream["string"]
Characters["string"] "string"
ToCharacterCode["string"] "string" ASCII
FromCharacterCode[n] ToCharacterCode
FromCharacterCode[{n1,n2,..}]ToCharacterCode
ToUpperCase[string]
ToLowerCase[string]
CharacterRange["c1","c2"] ASCII c1 c2
ToString[expr]
ToExpression[input]
Names["string"] ?string string
-
THIS IS THE FINAL CONFLICT
:BBS bbs.net.tsinghua.edu.cn[FROM:
202.115.15.197]