• 计算机代数系统对比:Computer Algebra Software: Mathematica, Maxima, Pari/GP


        Computer Algebra Software: Mathematica, Maxima, Pari/GP

                                            from Hyperpolyglot

                                            a side-by-side reference sheet



    mathematicamaximapari/gp
    version used
     
    8.05.212.3
    show version
     
    select About Mathematica in Mathematica menu$ maxima --version$ gp --version
    grammar and invocation
    mathematicamaximapari/gp
    interpreter
     
    $ maxima -b foo.mac$ gp -q foo.gp
    repl
     
    $ math$ maxima$ gp
    block delimiters
     
    stmt)block (  ) }
    statement separatoror sometimes newline

    before a newline suppresses output
    ;

    suppresses output:
    $
    newline or ;

    a trailing semicolon suppresses output
    end-of-line comment
     
    nonenone1 + 1 \\ addition
    multiple line comment
     
    1 + (* addition *) 11 + /* addition */ 11 + /* addition */ 1
    variables and expressions
    mathematicamaximapari/gp
    assignmenta = 3
    Set[a, 3]
    a: 3a = 3
    parallel assignment{a, b} = {3, 4}
    Set[{a, b}, {3, 4}]
    [a, b]: [3, 4]none
    compound assignment+= -= *= /=
    corresponding functions:
    AddTo SubtractFrom TimeBy DivideBy
    none+= -= *= /= %=
    increment and decrement++x --x
    PreIncrement[x] PreDecrement[x]
    x++ x--
    Increment[x] Decrement[x]
    nonereturn value after increment or decrement:
    x++ x--
    null
     
    Null
    null test
     
    undefined variable access
     
    treated as an unknown numbertreated as an unknown symboltreated as an unknown number
    remove variable bindingClear[x]
    Remove[x]
    kill(x)kill(x)
    conditional expression
     
    If[x > 0, x, -x]if is(x > 0) then x else -xif(x > 0, x, -x)
    arithmetic and logic
    mathematicamaximapari/gp
    true and false
     
    True Falsetrue false1 0
    falsehoods
     
    Falsefalse0
    logical operators! True || (True && False)
    Or[Not[True], And[True, False]]
    is(not true or (true and false))! 1 || (1 && 0)
    relational operators== != > < >= <=
    corresponding functions:
    Equal Unequal Greater Less GreaterEqual LessEqual
    = # > < >= <=== != > < >= <=
    arithmetic operators+ - * / Quotient Mod
    adjacent terms are multiplied, so * is not necessary. Quotient and Mod are functions, not binary infix operators. These functions are also available:
    Plus Subtract Times Divide
    + - * / quotient mod
    quotient and mod are functions, not binary infix operators
    + - * / none %
    integer division
     
    Quotient[a, b]quotient(a, b)divrem(a, b)[1]
    integer division by zerodividend is zero:
    Indeterminate
    otherwise:
    ComplexInfinity
    errorerror
    float divisionexact division:
    a / b
    float(a) / bexact division:
    a / b
    float division by zerodividend is zero:
    Indeterminate
    otherwise:
    ComplexInfinity
    errorerror
    power2 ^ 16
    Power[2, 16]
    2 ^ 162 ^ 16
    sqrtreturns symbolic expression:
    Sqrt[2]
    returns symbolic expression:
    sqrt(2)
    returns float:
    sqrt(2)
    sqrt -1
     
    I%i1.000 * I
    transcendental functionsExp Log Sin Cos Tan ArcSin ArcCos ArcTan ArcTan
    ArcTan accepts 1 or 2 arguments
    exp log sin cos tan asin acos atan atan2exp log sin cos tan asin acos atan none
    transcendental constants
    pi and the euler constant
    Pi E%pi %ePi exp(1)
    float truncation
    round towards zero, round to nearest integer, round down, round up
    IntegerPart Round Floor Ceilingtruncate round floor ceilingtruncate round floor ceil
    absolute value
    and signum
    Abs Signabs signabs sign
    integer overflow
     
    none, has arbitrary length integer typenone, has arbitrary length integer typenone, has arbitrary length integer type
    float overflow
     
    noneerrorerror
    rational constructionuse integer division:
    1 / 7
    use integer division:
    1 / 7
    use integer division:
    1 / 7
    rational decomposition
     
    Numerator Denominatorratnumer ratdenomnumerator denominator
    complex construction
     
    1 + 3I1 + 3 * %i1 + 3 * I
    complex decomposition
    real and imaginary part, argument and modulus, conjugate
    Re Im
    Arg Abs
    Conjugate
    realpart imagpart
    carg abs
    conjugate
    real imag
    ?? abs
    conj
    random number
    uniform integer, uniform float
    RandomInteger[{0, 99}]
    RandomReal[]
    random(100)
    random(1.0)
    random(100)
    ??
    random seed
    set, get
    SeedRandom[17]
    ??
    set_random_state(make_random_state(17));
    ??
    setrand(17)
    getrand()
    binary, octal, and hex literals2^^101010
    8^^52
    16^^2a
    base conversionBaseForm[42, 7]
    BaseForm[7^^60, 10]
    \\ 42 as powers of 7 up to 9th power:
    42 + O(7^10)
    strings
    mathematicamaximapari/gp
    string literals"don't say \"no\"""don't say \"no\"""don't say \"no\""
    newline in literalyesno; use \n escape
    string literal escapes\\ \" \b \f \n \r \t \ooo\n \t \" \\
    character accessCharacters["hello"][[1]]charat("hello", 1)
    chr and ordFromCharacterCode[{65}]
    ToCharacterCode["A"][[1]]
    lengthStringLength["hello"]slength("hello")length("hello")
    concatenate"one " <> "two " <> "three"concat("one", "two", "three");Str("one", "two", "three")
    index of substringStringPosition["hello", "el"][[1]][[1]]
    StringPosition returns an array of pairs, one for each occurrence of the substring. Each pair contains the index of the first and last character of the occurrence.
    ssearch("el", "hello")
    counts from one, returns false if not found
    extract substringStringTake["hello", {1, 4}]substring("hello", 1, 5)
    splitStringSplit["foo,bar,baz", ","]split("foo,bar,baz",",")
    joinStringJoin[Riffle[{"foo", "bar", "baz"}, ","]]simplode(["foo","bar","baz"],",")
    trimStringTrim[" foo "]strim(" ", " foo ")
    striml(" ", " foo")
    strimr(" ", "foo ")
    convert from string, to string7 + ToExpression["12"]
    73.9 + ToExpression[".037"]
    "value: " <> ToString[8]
    7 + parse_string("12")
    73.9 + parse_string(".037")
    case manipulationToUpperCase["foo"]
    ToLowerCase["FOO"]
    supcase("foo")
    sdowncase("FOO")
    regular expressions
    mathematicamaximapari/gp
    regex testre = RegularExpression["[a-z]+"]
    sc = StringCases["hello", re]
    Length[sc] > 0
    regex substitutions = "foo bar bar"
    re = RegularExpression["bar"]
    StringReplace[s, re -> "baz", 1]
    StringReplace[s, re -> "baz"]
    arrays
    mathematicamaximapari/gp
    literal{1, 2, 3}

    List[1, 2, 3]
    [1, 2, 3]\\ [1, 2, 3] is a vector literal:
    List([1, 2, 3])
    size
     
    Length[{1, 2, 3}]length([1, 2, 3])length(List([1, 2, 3]))
    empty test
     
    Length[{}] == 0emptyp([]);length(List([])) == 0
    lookup(* access time is O(1) *)
    (* indices start at one: *)
    {1, 2, 3}[[1]]

    Part[{1, 2, 3}, 1]
    /* access time is O(n) */
    /* indices start at one: */
    [1, 2, 3][1];
    \\ access time is O(1).
    \\ indices start at one:
    List([1, 2, 3])[1]
    update
     
    a[[1]] = 7a[1]: 7;listput(a, 7, 1)
    out-of-bounds behaviorleft as unevaluated Part[] expressioninvalid index errorout of allowed range error
    element index(* returns list of all positions: *)
    First /@ Position[{7, 8, 9, 9}, 9]
    /* returns list of all positions: */
    sublist_indices([7, 8, 9, 9], lambda([x], x = 9));
    none
    slice
     
    {1, 2, 3}[[1 ;; 2]]nonenone
    array of integers as index(* evaluates to {7, 9, 9} *)
    {7, 8, 9}[[{1, 3, 3}]]
    nonenone
    manipulate backa = {6,7,8}
    AppendTo[a, 9]
    elem = a[[Length[a]]]
    a = Delete[a, Length[a]]
    elem
    a: [6, 7, 8];
    a: endcons(9, a);
    last(a);
    /* no easy way to delete last element */
    a = List([6, 7, 8])
    listput(a, 9)
    elem = listpop(a)
    manipulate fronta = {6,7,8}
    PrependTo[a, 5]
    elem = a[[1]]
    a = Delete[a, 1]
    elem
    load("basic");

    a: [6, 7, 8];
    push(5, a);
    elem: pop(a);
    a = List([6, 7, 8]);
    listinsert(a, 5, 1);
    elem = a[1];
    listpop(a, 1);
    head
     
    First[{1, 2, 3}]first([1, 2, 3]);List([1, 2, 3])[1]
    tail
     
    Rest[{1, 2, 3}]rest([1, 2, 3]);none
    cons(* first arg must be an array *)
    Prepend[{2, 3}, 1]
    /* second arg must be an array */
    cons(1, [2, 3]);
    a = List([1, 2, 3]);
    listinsert(a, 1, 1);
    concatenate
     
    Join[{1, 2, 3}, {4, 5, 6}]append([1, 2, 3], [4, 5, 6])concat(List([1, 2, 3]), List([4, 5, 6]))
    replicate
     
    ten_zeros = Table[0, {i, 0, 9}]ten_zeros: makelist(0, 10);
    copy
     
    a2 = aa2: copylist(a);a2 = a
    iterate
     
    Function[x, Print[x]] /@ {1, 2, 3}a: [1, 2, 3];

    for i from 1 thru length(a) do print(a[i]);
    a = List([1, 2, 3])

    for(i=1, length(a), print(a[i]))
    reverse
     
    Reverse[{1, 2, 3}]reverse([1, 2, 3]);a = List([1, 2, 3])
    a2 = listcreate()
    while(i > 0, listput(a2, a[i]); i—)
    sortSort[{3, 1, 4, 2}]sort([3, 1, 4, 2]);a = List([3,1,4,2])
    listsort(a)
    a
    dedupe
     
    Union[{1, 2, 2, 3}]unique([1, 2, 2, 3]);
    membership
     
    MemberQ[{1, 2, 3}, 2]member(2, [1, 2, 3]);/* The Set() constructor takes an array or vector as
      an argument. It converts the elements to strings
      and sorts them, discarding duplicates.
      setsearch() returns the index of the element or zero
      if not in the set. */

    setsearch(Set([1, 2, 3]), 2)
    intersectionIntersect[{1, 2}, {2, 3, 4}]/* { } is literal notation for a set;
      use setify() to convert array to set */

    intersect({1, 2}, {2, 3, 4});
    setintersect(Set([1, 2]), Set([2, 3, 4]))
    union
     
    Union[{1, 2}, {2, 3, 4}]union({1, 2}, {2, 3, 4});setunion(Set([1, 2]), Set([2, 3, 4]))
    relative complement, symmetric differenceComplement[{1, 2, 3}, {2}]
    none
    setdifference({1, 2, 3}, {2});
    symmdifference({1, 2}, {2, 3, 4});
    setminus(Set([1, 2, 3]), Set([2]))
    mapFunction[x, x x] /@ {1, 2, 3}

    Map[Function[x, x x], {1, 2, 3}]
    map(lambda([x], x * x), [1, 2, 3])
    filter
     
    Select[{1, 2, 3}, # > 2 &]sublist([1, 2, 3], lambda([x], x > 2))
    reduceFold[Plus, 0, {1, 2, 3}]/* returns -4: */
    lreduce(lambda([x,y], x - y), [1, 2, 3])

    /* returns 2: */
    rreduce(lambda([x,y], x - y), [1, 2, 3])
    universal and existential testsnoneevery(evenp, [1, 2, 3]);
    some(evenp, [1, 2, 3]);
    min and max elementMin[{1, 2, 3}]
    Max[{1, 2, 3}]
    apply(min, [1, 2, 3]);
    apply(max, [1, 2, 3]);
    shuffle and samplex = {3, 7, 5, 12, 19, 8, 4}

    RandomSample[x]
    RandomSample[x, 3]
    random_permutation([3, 7, 5, 12, 19, 8, 4]);
    zip(* list of six elements: *)
    Riffle[{1, 2, 3}, {"a", "b", "c"}]
    /* list of six elements: */
    join([1, 2, 3], ["a", "b", "c"])
    sequences
    mathematicamaximapari/gp
    rangeRange[1, 100]makelist(i, i, 1, 100)
    arithmetic sequence of integers with difference 10Range[1, 100, 10]
    arithmetic sequence of floats with difference 0.1Range[1, 100, .1]
    multidimensional-arrays
    mathematicamaximapari/gp
    dictionaries
    mathematicamaximapari/gp
    record literalr = { n -> 10, avg -> 3.7, sd -> 0.4}defstruct(point(x, y, z));
    p: point(2, 3, 5);
    record member accessn /. rp@x
    functions
    mathematicamaximapari/gp
    definitionadd[a_, b_] := a + b

    (* alternate syntax: *)
    add = Function[{a, b}, a + b]
    add(a, b) := a + b;add(x, y) = x + y
    invocationadd[3, 7]

    add @@ {3, 7}
    add(3, 7);add(3, 7)
    return value
    function value
    anonymous functionFunction[{a, b}, a + b]

    (#1 + #2) &
    lambda([a, b], a + b)
    missing argumenterror
    extra argumenterror
    default argument
    variable number of argumentsf(x, [L]) := if emptyp(L) then x else [x, apply("+", L)];
    f(1);
    f(1, 2, 3);
    execution control
    mathematicamaximapari/gp
    ifIf[x > 0,
      Print["positive"],
      If[x < 0,
        Print["negative"],
        Print["zero"]]]
    if (is(x > 0)) then print("positive") elseif (is(x < 0)) then print("negative") else print("zero")if(x > 0, \
      print("positive"), \
      if(x < 0, \
        print("negative"), \
        print("zero")))
    whilei = 0
    While[i < 10, Print[i]; i++]
    i = 0
    while(i < 10, print(i); i++)
    forFor[i = 0, i < 10, i++, Print[i]]for i from 0 thru 9 do print(i);for(i=0, 9, print(i))
    break/continueBreak[] Continue[]break continue
    raise exceptionThrow["failed"]throw("failed");

    error("failed");
    error("failed")
    handle exceptionPrint[Catch[Throw["failed"]]]catch(throw("failed"));

    errcatch(error("failed"));
    finally blocknone
    files
    mathematicamaximapari/gp
    write to stdoutPrint["hello"]print("hello")print("hello")
    read entire file into string or arrays = Import["/etc/hosts"]
    a = StringSplit[s, "\n"]
    redirect to file
    libraries and namespaces
    mathematicamaximapari/gp
    load
    reflection
    mathematicamaximapari/gp
    list function documentation???
    get function documentation?Tan
    Information[Tan]
    ? tan
    describe(tan)
    ? tan
    grep documentation?? tan
    query data typeHead[x]bigfloatp(x)
    floatnump(x)
    integerp(x)
    numberp(x)
    ratnump(x)
    stringp(x)
    listp(x)
    type(x)
    list variables in scope? 0
    algebra
    mathematicamaximapari/gp
    solution to an equationSolve[x^3 + x + 3 == 0, x]solve(x^3 + x + 3, x)
    solution to two equationsSolve[x + y == 3 && x == 2y,
      {x, y}]
    solve([x+y=3, x=2*y], [x, y])
    numerical approximationN[Exp[1]]
    Exp[1] + 0.
    N[Exp[1], 10]
    float(exp(1))1/7 + 0.
    expand polynomialExpand[(1 + x)^5]expand((1+x)^5)
    factor polynomialFactor[3 + 10 x + 9 x^2 + 2 x^3]factor(3 + 10*x + 9*x^2 + 2*x^3)
    add fractionsTogether[a/b + c/d]ratsimp(a/b + c/d)
    decompose fractionApart[(b c + a d)/(b d)]
    calculus
    mathematicamaximapari/gp
    differentationD[x^3 + x + 3, x]diff(x^3 + x + 3, x)
    diff(sin(x), x)
    P = x^3 + x + 3
    P'
    sin(x)'
    higher order differentiationD[Log[x], {x, 3}]diff(log(x), x, 3);
    integrationIntegrate[x^3 + x + 3, x]
    Integrate[x^3 + x + 3, {x, 0, 1}]
    integrate(x^3 + 3*x + 3, x);
    integrate(x^3 + 3*x + 3, x, 0, 1);
    find minimal valueMinimize[Sqrt[a^2 + x^2] + Sqrt[(b - x)^2 + c^2], x]
    number theory
    mathematicamaximapari/gp
    number testsIntegerQ[7]
    PrimeQ[7]
    rational test?
    real test?
    integerp(7)
    primep(7)
    ratnump(1/7)
    solve diophantine equationSolve[a^2 + b^2 == c^2 &&
    a > 0 && a < 10 &&
    b > 0 && b < 10 &&
    c > 0 && c < 10,
    {a, b, c}, Integers]
    factorial10!10!10!
    binomial coefficientBinomial[10,3]binomial(10,3)
    greatest common divisorGCD[14, 21]gcd(14, 21)gcd(14, 21)
    prime factorsreturns {{2, 2}, {3, 1}, {7, 1}}
    FactorInteger[84]
    factor(84)returns [2,2; 3,1; 7,1]
    factor(84)
    Euler totientEulerPhi[256]totient(256)
    vectors
    mathematicamaximapari/gp
    vector literal(* same as array: *)
    {1, 2, 3}
    /* same as list: */
    [1, 2, 3]
    [1, 2, 3]
    vector coordinateindices start at one:
    {1,v2, 3}[[1]]
    indices start at one:
    [1, 2, 3][1]
    indices start at one:
    [1, 2, 3][1]
    vector dimension
     
    Length[{1, 2, 3}]length([1, 2, 3])length([1, 2, 3])
    element-wise arithmetic operators+ - * /
    adjacent lists are multiplied element-wise
    + - * /+ -
    vector length mismatch
     
    errorerrorerror
    scalar multiplication3 {1, 2, 3}
    {1, 2, 3} 3
    * may also be used
    3 * [1, 2, 3]
    [1, 2, 3] * 3
    3 * [1, 2, 3]
    [1, 2, 3] * 3
    dot product{1, 1, 1} . {2, 2, 2}
    Dot[{1, 1, 1}, {2, 2, 2}]
    [1,1,1] . [2,2,2]
    cross productCross[{1, 0, 0}, {0, 1, 0}]load("vect");

    express([1, 0, 0] ~ [0, 1, 0]);
    normsNorm[{1, 2, 3}, 1]
    Norm[{1, 2, 3}]
    Norm[{1, 2, 3}, Infinity]
    matrices
    mathematicamaximapari/gp
    literal or constructorA = {{1, 2}, {3, 4}}
    B = {{4, 3}, {2, 1}}
    A: matrix([1, 2], [3, 4]);
    B: matrix([4, 3], [2, 1]);
    A = [1, 2; 3, 4]
    B = [4, 3; 2, 1]
    zero, identity, ones, diagonal matrixConstantArray[0, {3, 3}]
    IdentityMatrix[3]
    ConstantArray[1, {3, 3}]
    DiagonalMatrix[{1, 2, 3}]
    zeromatrix(3, 3)
    ident(3)
    1 + zeromatrix(3, 3)
    diag_matrix(1, 2, 3)
    dimensions
    rows, columns
    Length[A]
    Length[A[[1]]]
    matrix_size(A)[1]
    matrix_size(A)[2]
    element accessA[[1, 1]]A[1, 1]A[1, 1]
    row accessA[[1]]as list:
    A[1]
    as 1xn matrix:
    row(A, 1)
    column accesscol(A, 1)
    submatrix access# [[1]] & /@ A
    scalar multiplication3 A
    A 3
    * can also be used
    3 * A
    A * 3
    element-wise operators+ - * /
    adjacent matrices are multiplied element-wise
    + - * /
    multiplicationA . BA . B
    kronecker productKroneckerProduct[A, B]kronecker_product(A, B);
    comparisonA == B
    A != B
    is(A = B)
    is(A # B)
    normsNorm[A, 1]
    Norm[A]
    Norm[A, Infinity]
    Norm[A, "Frobenius"]
    transposeTranspose[A]
    conjugate transposeA = {{I, 2 I}, {3 I, 4 I}}
    ConjugateTranspose[A]
    inverseInverse[A]
    determinantDet[A]matdet(A)
    traceTr[A]trace(A)
    eigenvaluesEigenvalues[A]
    eigenvectorsEigenvectors[A]
    system of equationsSolve[A. {x, y} == { 2, 3}, {x, y}]
    distributions
    mathematicamaximapari/gp
    normalnd = NormalDistribution[0,1]
    RandomVariate[nd]
    load(distrib);
    random_normal(0,1);
    exponentialed = ExponentialDistribution[1]
    RandomVariate[ed]
    load(distrib);
    random_exp(1);
    poissonpd = PoissonDistribution[1]
    RandomVariate[pd]
    load(distrib);
    random_poisson(1);
    univariate charts
    mathematicamaximapari/gp
    5039793334_f76edece33_m.jpgvertical bar chartBarChart[{7, 3, 8, 5, 5},
      ChartLegends->
        {"a","b","c","d","e"}]
    5039776078_cc38a4ff5f_m.jpg
    horizontal bar chart
    BarChart[{7, 3, 8, 5, 5}, BarOrigin -> Left]
    5037819710_d932767cd5_m.jpg pie chartPieChart[{7, 3, 8, 5, 5}]
    5037399669_13c8e585e0_m.jpg
    stem-and-leaf plot
    Needs["StatisticalPlots`"]
    nd = NormalDistribution[0, 1]
    n100 = RandomVariate[nd, 100]
    StemLeafPlot[20 * n100]
    5037415497_4c6fbfcab2_m.jpghistogramnd = NormalDistribution[0, 1]
    Histogram[RandomReal[nd, 100], 10]
    5037525393_7ac86e81c3_m.jpg box-and-whisker plotnd = NormalDistribution[0, 1]
    n100 = RandomVariate[nd, 100]
    BoxWhiskerChart[d]

    ed = ExponentialDistribution[1]
    e100 = RandomVariate[ed, 100]
    u100 = RandomReal[1, 100]
    d = {n100, e100, u100}
    BoxWhiskerChart[d]
    set chart titleBoxWhiskerChart[data,
      PlotLabel -> "chart example"]
    chart optionsPlotLabel -> "an example"

    AxisLabel -> {"time", "distance"}
    bivariate charts
    mathematicamaximapari/gp
    5039126187_e340b3f4aa_m.jpg
    stacked bar chart
    d = {{7, 1}, {3, 2}, {8, 1},
      {5, 3}, {5, 1}}
    BarChart[d, ChartLayout ->
      "Stacked"]
    5267212089_a7749bbe3e_s.jpgscatter plotnd = NormalDistribution[0, 1]
    rn = Function[RandomReal[nd]]
    d = {rn[],rn[]} & /@ Range[1,50]
    ListPlot[d]
    5267975488_2216ae147e_s.jpglinear regression lined = Table[{i,
      2 i + RandomReal[{-5, 5}]},
      {i, 0, 20}]
    model = LinearModelFit[d, x, x]
    Show[ListPlot[d],
      Plot[model["BestFit"],
        {x, 0, 20}]]
    5267434941_f8537c9d26_s.jpgpolygonal line plotf = Function[i, {i, rn[]}]
    d = f /@ Range[1, 20]
    ListLinePlot[d]
    5268071368_75c3aee42e_t.jpgarea chartd = {{7, 1, 3, 2, 8},
      {1, 5, 3, 5, 1}}
    sd = {d[[1]], d[[1]] + d[[2]]}
    ListLinePlot[sd, Filling ->
      {1 -> {Axis, LightBlue},
       2 -> {{1}, LightRed}}]
    5268229340_0b96b5e223_s.jpgcubic splined = Table[{i, RandomReal[nd]},
      {i, 0, 20}]
    f = Interpolation[d,
      InterpolationOrder -> 3]
    Show[ListPlot[d],
      Plot[f[x], {x, 0, 20}]]
    5268208606_b745646ea6_s.jpgfunction plotPlot[Sin[x], {x, -4, 4}]plot2d(sin(x),[x,-4,4]);ploth(x=-4, 4, sin(x))
    5267567389_27a19429e4_s.jpgquantile-quantile plotnd = NormalDistribution[0, 1]
    d1 = RandomReal[1, 50]
    d2 = RandomReal[nd, 50]
    QuantilePlot[d1, d2]
    axis labeld = Table[{i, i^2}, {i, 1, 20}]
    ListLinePlot[d,
      AxesLabel -> {x, x^2}]
    plot2d(sin(x), [x,-4,4], [ylabel,"sine function"]);
    logarithmic y-axisLogPlot[{x^2, x^3, x^4, x^5},
      {x, 0, 20}]
    trivariate charts
    mathematicamaximapari/gp
    3d scatter plotnd = NormalDistribution[0,1]
    d = RandomReal[nd, {50, 3}]
    ListPointPlot3D[d]
    5268191292_a75a367c39_s.jpgadditional data setnd = NormalDistribution[0, 1]
    x1 = RandomReal[nd, 20]
    x2 = RandomReal[nd, 20]
    ListLinePlot[{x1, x2}]
    bubble chartnd = NormalDistribution[0,1]
    d = RandomReal[nd, {50, 3}]
    BubbleChart[d]
    surface plotPlot3D[Sinc[Sqrt[x^2 + y^2]],
      {x, -25, 25},
      {y, -25, 25}]
    sinc(x) := sin(%pi*x)/(%pi*x);sinc(x) := sin(%pi*x)/(%pi*x);
    plot3d(sinc(sqrt(x^2+y^2)),[x,-25,25],[y,-25,25]);
    __________________________________________________________________________________________________________________________________________________________________

    version used

    The version of software used to check the examples in the reference sheet.

    show version

    How to determine the version of an installation.

    Grammar and Invocation

    interpreter

    How to execute a script.

    pari/gp

    The shebang style notation doesn't work because GP doesn't recognize the hash tag # as the start of a comment.

    The -q option suppresses the GP startup message.

    After the script finishes it will drop the user into the REPL unless there is a quit statement in the script:

    print("Hello, World!")
    
    quit
    

    repl

    How to launch a command line read-eval-print loop for the language.

    mathematica:

    One can create a REPL called math on Mac OS X with the following command:

    $ sudo ln -s /Applications/Mathematica.app/Contents/MacOS/MathKernel /usr/local/bin/math
    
    $ math
    

    block delimiters

    How blocks are delimited.

    statement separator

    How statements are separated.

    end-of-line comment

    Character used to start a comment that goes to the end of the line.

    multiple line comment

    Variables and Expressions

    assignment

    How to perform assignment.

    In all three languages an assignment is an expression that evaluates to the right side of the expression. Assignments can be chained to assign the same value to multiple variables.

    mathematica:

    The Set function behaves identically to assignment and can be nested:

    Set[a, Set[b, 3]]
    

    parallel assignment

    How to assign values in parallel.

    Parallel assignment can be used to swap the values held in two variables.

    compound assignment

    The compound assignment operators.

    increment and decrement

    null

    null test

    How to test if a value is null.

    undefined variable access

    remove variable binding

    How to remove a variable. Subsequent references to the variable will be treated as if the variable were undefined.

    conditional expression

    A conditional expression.

    Arithmetic and Logic

    true and false

    The boolean literals.

    falsehoods

    Values which evaluate to false in a conditional test.

    logical operators

    The boolean operators.

    relational operators

    The relational operators.

    arithmetic operators

    The arithmetic operators.

    integer division

    How to compute the quotient of two integers.

    integer division by zero

    The result of dividing an integer by zero.

    float division

    How to perform float division, even if the arguments are integers.

    float division by zero

    The result of dividing a float by zero.

    power

    How to compute exponentiation.

    Note that zero to a negative power is equivalent to division by zero, and negative numbers to a fractional power may have multiple complex solutions.

    sqrt

    The square root function.

    For positive arguments the positive square root is returned.

    sqrt -1

    How the square root function handles negative arguments.

    mathematica:

    An uppercase I is used to enter the imaginary unit, but Mathematica displays it as a lowercase i.

    transcendental functions

    The standard transcendental functions such as one might find on a scientific calculator.

    The functions are the exponential (not to be confused with exponentiation), natural logarithm, sine, cosine, tangent, arcsine, arccosine, arctangent, and the two argument arctangent.

    transcendental constants

    The transcendental constants pi and e.

    The transcendental functions can used to computed to compute the transcendental constants:

    pi = acos(-1)
    pi = 4 * atan(1)
    e = exp(1)
    

    float truncation

    Ways to convert a float to a nearby integer.

    absolute value

    How to get the absolute value and signum of a number.

    integer overflow

    What happens when the value of an integer expression cannot be stored in an integer.

    The languages in this sheet all support arbitrary length integers so the situation does not happen.

    float overflow

    What happens when the value of a floating point expression cannot be stored in a float.

    rational construction

    How to construct a rational number.

    rational decomposition

    How to extract the numerator and denominator from a rational number.

    complex construction

    How to construct a complex number.

    complex decomposition

    How to extract the real and imaginary part from a complex number; how to extract the argument and modulus; how to get the complex conjugate.

    random number

    How to generate a random integer or a random float.

    random seed

    How to set or get the random seed.

    maxima:

    The seed is set to a fixed value at start up.

    pari/gip:

    The seed is set to a fixed value at start up.

    mathematica:

    The seed is not set to the same value at start up.

    binary, octal, and hex literals

    Binary, octal, and hex integer literals.

    mathematica:

    The notation works for any base from 2 to 36.

    Strings

    string literals

    newline in literal

    character access

    chr and ord

    length

    concatenate

    index of substring

    extract substring

    split

    convert from string, to string

    How to convert strings to numbers and vice versa.

    join

    trim

    case manipulation

    sprintf

    Regular Expressions

    regex test

    How to test whether a string matches a regular expression.

    regex substitution

    How to replace substrings which match a regular expression.

    Arrays

    literal

    The notation for an array literal.

    size

    The number of elements in the array.

    empty test

    How to test whether an array is empty.

    lookup

    How to access an array element by its index.

    update

    How to change the value stored at an array index.

    out-of-bounds behavior

    What happens when an attempt is made to access an element at an out-of-bounds index.

    element index

    How to get the index of an element in an array.

    slice

    How to extract a subset of the elements. The indices for the elements must be contiguous.

    array of integers as index

    manipulate back

    manipulate front

    head

    tail

    cons

    concatenate

    replicate

    copy

    How to copy an array. Updating the copy will not alter the original.

    iterate

    reverse

    sort

    dedupe

    membership

    How to test whether a value is an element of a list.

    intersection

    How to to find the intersection of two lists.

    union

    How to find the union of two lists.

    relative complement, symmetric difference

    How to find all elements in one list which are not in another; how to find all elements which are in one of two lists but not both.

    map

    filter

    reduce

    universal and existential tests

    min and max element

    shuffle and sample

    How to shuffle an array. How to extract a random sample from an array without replacement.

    zip

    How to interleave two arrays.

    Sequences

    Multidimensional Arrays

    Dictionaries

    record literal

    record member access

    Functions

    definition

    invocation

    function value

    Execution Control

    if

    How to write a branch statement.

    mathematica:

    The 3rd argument (the else clause) of an If expression is optional.

    while

    How to write a conditional loop.

    mathematica:

    Do can be used for a finite unconditional loop:

    Do[Print[foo], {10}]
    

    for

    How to write a C-style for statement.

    break/continue

    How to break out of a loop. How to jump to the next iteration of a loop.

    raise exception

    How to raise an exception.

    handle exception

    How to handle an exception.

    finally block

    How to write code that executes even if an exception is raised.

    Files

    Libraries and Namespaces

    Reflection

    ]function-documentation]

    function documentation

    How to get the documentation for a function.

    Algebra

    Calculus

    Number Theory

    Vectors

    vector literal

    The notation for a vector literal.

    vector coordinate

    How to get one of the coordinates of a vector.

    vector dimension

    How to get the number of coordinates of a vector.

    element-wise arithmetic operators

    How to perform an element-wise arithmetic operatio on vectors.

    vector length mismatch

    What happens when an element-wise arithmetic operation is performed on vectors of different dimension.

    scalar multiplication

    How to multiply a scalar with a vector.

    dot product

    How to compute the dot product of two vectors.

    cross product

    How to compute the cross product of two three-dimensional vectors.

    norms

    How to compute the norm of a vector.

    Matrices

    literal or constructor

    Literal syntax or constructor for creating a matrix.

    mathematica:

    Matrices are represented as lists of lists. No error is generated if one of the rows contains too many or two few elements. The MatrixQ predicate can be used to test whether a list of lists is matrix: i.e. all of the sublists contain numbers and are of the same length.

    Matrices are displayed by Mathematica using list notation. To see a matrix as it would be displayed in mathematical notation, use the MatrixForm function.

    dimensions

    How to get the dimensions of a matrix.

    element access

    How to access an element of a matrix. All languages described here follow the convention from mathematics of specifying the row index before the column index.

    row access

    How to access a row.

    column access

    How to access a column.

    submatrix access

    How to access a submatrix.

    scalar multiplication

    How to multiply a matrix by a scalar.

    element-wise operators

    Operators which act on two identically sized matrices element by element. Note that element-wise multiplication of two matrices is used less frequently in mathematics than matrix multiplication.

    multiplication

    How to multiply matrices. Matrix multiplication should not be confused with element-wise multiplication of matrices. Matrix multiplication in non-commutative and only requires that the number of columns of the matrix on the left match the number of rows of the matrix. Element-wise multiplication, by contrast, is commutative and requires that the dimensions of the two matrices be equal.

    kronecker product

    The Kronecker product is a non-commutative operation defined on any two matrices. If A is m x n and B is p x q, then the Kronecker product is a matrix with dimensions mp x nq.

    comparison

    How to test two matrices for equality.

    norms

    How to compute the 1-norm, the 2-norm, the infinity norm, and the frobenius norm.

    Distributions

    univariate-charts Univariate Charts

    A univariate chart can be used to display a list or array of numerical values. Univariate data can be displayed in a table with a single column or two columns if each numerical value is given a name. A multivariate chart, by contrast, is used to display a list or array of tuples of numerical values.

    In order for a list of numerical values to be meaningfully displayed in a univariate chart, it must be meaningful to perform comparisons (<, >, =) on the values. Hence the values should have the same unit of measurement.

    vertical bar chart

    A chart which represents values with rectangular bars which line up on the bottom. It is a deceptive practice for the bottom not to represent zero, even if a y-axis with labelled tick marks or grid lines is provided. A cut in the vertical axis and one of the bars may be desirable if the cut value is a large outlier. Putting such a cut all of the bars near the bottom is a deceptive practice similar not taking to the base of the bars to be zero, however.

    Another bad practice is the 3D bar chart. In such a chart heights are represented by the height of what appear to be three dimensional blocks. Such charts impress an undiscriminating audience but make it more difficult to make a visual comparison of the charted quantities.

    mathematica

    horizontal bar chart

    A bar chart in which zero is the y-axis and the bars extend to the right.

    pie chart

    A bar chart displays values using the areas of circular sectors or equivalently, the lengths of the arcs of those sectors. A pie chart implies that the values are percentages of a whole. The viewer is likely to make an assumption about what the whole circle represents. Thus, using a pie chart to show the revenue of some companies in a line of business could be regarded as deceptive if there are other companies in the same line of business which are left out. The viewer may mistakenly assume the whole circle represents the total market.

    If two values are close in value, people cannot determine visually which of the corresponding sectors in a pie chart is larger without the aid of a protractor. For this reason many consider bar charts superior to pie charts.

    Many software packages make 3D versions of pie charts which communicate no additional information and in fact make it harder to interpret the data.

    stem-and-leaf plot

    histogram

    box-and-whisker plot

    set chart title

    Bivariate Charts

    stacked bar chart

    Trivariate Charts

    Mathematica

    Mathematica Documentation Center
    WolframAlpha

    Maxima

    Maxima Manual

    Pari/GP

    A Tutorial for Pari/GP (pdf)
    Pari/GP Functions by Category
    Pari/GP Reference Card (pdf)


    源地址:http://hyperpolyglot.org/computer-algebra


  • 相关阅读:
    581. 最短无序连续子数组
    217. 存在重复元素
    189. 旋转数组
    169. 多数元素
    122. 买卖股票的最佳时机 II
    119. 杨辉三角 II
    118. 杨辉三角
    外显子分析思路总结(Exome Sequencing Analysis review)
    宁夏采样记20181129
    haploview出现“results file must contain a snp column”的解决方法
  • 原文地址:https://www.cnblogs.com/enjoy233/p/3011149.html
Copyright © 2020-2023  润新知