atlas 2 for Maple

atlas package Overview

Declaration operators

Calculation operators

Standard DG operators

Utility operators

Features List & Examples

atlasWizard - Maplet™

Template Worksheets

Licenses & Pricing

atlas[Constants] - declaration of constants 

Calling Sequence: 

    Constants(C1, C2, ..., Ci, ... , Cn) 

Parameters: 

    C1, C2, ..., Ci, ... , Cn - constants identifiers 

Description: 

  • In the atlas package any identifier is treated as 0-form i.e. as non-constant scalar (if it not declared as constant, p-form, tensor etc. (see atlas[types])).
 

  • The Constants procedure allows one to declare constants.
 

  • In the atlas package constants are constant 0-forms.
 

  • Some constants are predefined such as Catalan, Pi, I and _Z (for RootOf procedure)
 

  • The constant identifier can be either symbolic or indexed.
 

Examples: 

> restart:
with(atlas):
 

Declare some constants:  

> Constants(lambda,alpha[1],C,c[k]);
 

{`+`(`-`(I)), I, C, Pi, _Z, Catalan, lambda, c[k], alpha[1]}(2.1)
 

Verify that C and c[k]  are constants using kind (see atlas[kind]) and type procedures:  

> kind(C);
 

[0, 0](2.2)
 

> type(C,const);
 

true(2.3)
 

> kind(c[i]);
 

[0, 0](2.4)
 

> type(c[j],const);
 

true(2.5)
 

> type(c[3],const);
 

true(2.6)
 

> 'd(Sum(c[i]*x[i],i=1..n))'=d(Sum(c[i]*x[i],i=1..n));
 

d(Sum(`*`(c[i], `*`(x[i])), i = 1 .. n)) = Sum(`*`(c[i], `*`(d(x[i]))), i = 1 .. n)(2.7)
 

Verify that lambda is a constant using exterior derivative operator (see atlas[d]):  

> 'd(lambda)'=d(lambda);
 

d(lambda) = 0(2.8)
 

Some more verifications:  

> 'd(lambda*F+alpha[1]*G-Pi*S)'=d(lambda*F+alpha[1]*G-Pi*S);
 

d(`+`(`*`(lambda, `*`(F)), `*`(alpha[1], `*`(G)), `-`(`*`(Pi, `*`(S))))) = `+`(`*`(lambda, `*`(d(F))), `*`(alpha[1], `*`(d(G))), `-`(`*`(Pi, `*`(d(S)))))(2.9)
 

As F, G, S was not declared as something thus they are nonconstant scalars (0-forms) by defaults: 

> 'd(F*G)'=d(F*G);
 

d(`*`(F, `*`(G))) = `+`(`*`(d(F), `*`(G)), `*`(F, `*`(d(G))))(2.10)
 

For better understanding (see atlas[Functions]):  

> Functions(S=S(x,y),y=y(z));
 

{S, y}(2.11)
 

Now S and y are functions: 

> 'd(y)'=d(y);
 

d(y) = `*`(Diff(y, z), `*`(d(z)))(2.12)
 

Obviously that: 

> 'd(S)'=d(S);
 

d(S) = `+`(`*`(Diff(S, x), `*`(d(x))), `*`(Diff(S, y), `*`(Diff(y, z), `*`(d(z)))))(2.13)
 

And corresponding exterior product (see atlas[`&^`]) is: 

> 'd(S)&^d(y)'=d(S)&^d(y);
 

`&^`(d(S), d(y)) = `*`(Diff(y, z), `*`(Diff(S, x), `*`(`&^`(d(x), d(z)))))(2.14)
 

As n is 0-form (just as x) then:
'd(x^n)'=d(x^n);
 

d(`^`(x, n)) = `+`(`*`(n, `*`(`^`(x, `+`(n, `-`(1))), `*`(d(x)))), `*`(`^`(x, n), `*`(ln(n), `*`(d(n)))))(2.15)
 

lambda declared as a constant thus:
'd(x^lambda)'=d(x^lambda); 

d(`^`(x, lambda)) = `*`(lambda, `*`(`^`(x, `+`(lambda, `-`(1))), `*`(d(x))))(2.16)
 

Let's see "who is who" 

> Who([S,F,lambda,x,y]);
 

S: function
F: 0 - form
lambda: constant
x: 0 - form
y: function
 

> Who();
 

piecewise(Domains, {}, Mappings, {}, Tensors, {}, Forms, {}, Constants, {`+`(`-`(I)), I, C, Pi, _Z, Catalan, lambda, c[k], alpha[1]}, Functions, {S, y})(2.17)
 

>
 

See Also:  

atlas, atlas[Functions], atlas[Forms], atlas[Vectors], atlas[Tensors], atlas[d], atlas[`&^`], atlas[Who].