Maple Online Help

https://www.maplesoft.com/support/help/Maple/
Admin
Maple is powerful and easy-to-use math software, and this content provides its online help...
Tokens:98,871
Snippets:821
Trust Score:10
Update:9 months ago
Show doc for...
Tokens:
Raw
### Maple: Fetch Data with HTTP Get Command

Source: https://www.maplesoft.com/support/help/Maple/view_path=HTTP

This example shows how to use the Get command from the HTTP package to fetch data from a given URL. It then demonstrates how to extract the status code from the result.

```maple
result := Get("http://www.maplesoft.com/"):
Code(result[1])
```

--------------------------------

### fdiscont Function Usage Examples

Source: https://www.maplesoft.com/support/help/Maple/view_path=fdiscont

Demonstrates the usage of the fdiscont function with different expressions, ranges, and resolutions. It shows how to obtain features of mathematical expressions and how parameters like 'newton' can affect the output. The examples cover various mathematical functions and demonstrate the impact of resolution on the returned features.

```maple
> Digits:=10:
> fdiscont(round(3*x-12),x=0..1,10^(-7))
```

```maple
> fdiscont(GAMMA(x^2),x=-10..0,0.0001)
```

```maple
> fdiscont(arctan(12*tan(2*x))/(x^2-1),x=-Pi..2*Pi)
```

```maple
> fdiscont(1/(x-1)+1/(x-9851000)+1/(x-3),x=0..4,10^(-2),newton=true)
```

```maple
> fdiscont(abs(x^10000),x=-1..1,0.001)
```

```maple
> fdiscont(tan(10*x),x=0..Pi,0.01,newton=true)
```

```maple
> fdiscont(sin(75*x),x=0..Pi,0.1)
```

```maple
> fdiscont(sin(75*x),x=0..Pi,0.001)
```

--------------------------------

### Maple Floating-Point Number Constructor Examples

Source: https://www.maplesoft.com/support/help/Maple/view_path=float

Demonstrates the direct use of Maple's floating-point number constructors and common operations. Includes examples of positive and negative decimals, scientific notation, and multiplication of large floating-point numbers.

```maple
2.3
2.
-.3
x:=-2.3e4
(1.2e6)*x
```

--------------------------------

### Factor an integer

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example shows how to factor an integer. The `factor` command will return the prime factorization of the integer. For comparison, `ifactor` is also shown, which also provides the prime factorization.

```maple
factor(6)
```

```maple
ifactor(6)
```

--------------------------------

### Factor a polynomial with floating-point coefficients

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates factoring a polynomial where the coefficients are floating-point numbers. The `factor` command performs a numerical factorization in this case.

```maple
factor(x^3+5.0)
```

--------------------------------

### Maple Example: Profiling and Call Graph Generation

Source: https://www.maplesoft.com/support/help/Maple/view_path=exprofile

This example demonstrates a typical workflow in Maple for profiling functions. It defines recursive procedures, enables profiling, writes output to a file, executes the main routine, disables profiling, and then uses `exprofile` and `excallgraph` to analyze the results.

```maple
a:=proc(); b(100); end proc:
b:=proc(n);
if n>0 then c(n-2); end if;
end proc:
c:=proc(n);
if n>0 then b(n+1); end if;
end proc:
kernelopts(profile=true):
writeto('output'):
a():
kernelopts(profile=false):
writeto(terminal):
exprofile('output',α):
excallgraph('output')
```

--------------------------------

### Factor a polynomial over rationals using `Split` and `convert`

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates how to factor a polynomial over the rationals and then represent these factors using radicals. It involves using the `Split` function from `PolynomialTools` and converting the result.

```maple
with(PolynomialTools):
a := x^4-x^2+1:
factor(a)
```

```maple
a1 := Split(a, x):
convert(a1, radical)
```

--------------------------------

### Factor a sum of cubes

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates factoring a sum of cubes, a common algebraic identity. The `factor` command correctly applies this identity.

```maple
factor(x^3+y^3)
```

--------------------------------

### Factor a rational expression

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example shows factoring a rational expression which involves fractions. The `factor` command will factor both the numerator and the denominator, and simplify the overall expression.

```maple
factor(1/x^2-1+1/(x^2+3*x+2))
```

--------------------------------

### Factor a polynomial

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates factoring a simple polynomial expression. The `factor` command breaks down the polynomial into its irreducible factors over the default domain (typically rational numbers).

```maple
factor(6*x^2+18*x-24)
```

--------------------------------

### fdiff Command Syntax and Examples

Source: https://www.maplesoft.com/support/help/Maple/view_path=fdiff

Demonstrates various ways to use the fdiff command for symbolic differentiation and numerical evaluation. It covers differentiating expressions, procedures, and operators with respect to specified variables at given points. The examples highlight default behaviors and alternative syntaxes.

```maple
fdiff(f(x,y),[x,x,y],{x=a,y=b});
evalf((∂3∂x2∂yf(x,y)){x=a,y=b});
evalf(D1,2,2(f)(a,b));
fdiff(f(x,y),[x,y],{x=a,y=b});
fdiff(f(x,y),{x=a,y=b});
fdiff(f(x),x=a);
fdiff(f(x),x,x=a);
fdiff(f(x,y,z),x,{x=a,y=b,z=c});
fdiff(f,[1,2,2],[a,b]);
```

--------------------------------

### Factor a multivariate polynomial

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates factoring a polynomial with multiple variables. The `factor` command attempts to find the common factors across all terms in the expression.

```maple
factor(x^3-y^3)
```

--------------------------------

### Factor a polynomial with no simple factors

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example shows a polynomial that does not have simple factors over the rational numbers. The `factor` command returns the polynomial itself if no further factorization is possible in the default domain.

```maple
factor(x^3+5)
```

--------------------------------

### Find Extrema with Constraints and Candidate Points (Maple)

Source: https://www.maplesoft.com/support/help/Maple/view_path=extrema

This example showcases finding extrema of a multivariate expression with multiple constraints using Maple. It also demonstrates how to capture the candidate points for these extrema using the 's' parameter. The constraints are provided as a set of equations.

```maple
> f := (x^2+y^2)^(1/2) - z;
> g1 := x^2+y^2=16;
> g2 := x+y+z=10;
> extrema(f, {g1, g2}, {x, y, z}, 's');
{ -6 - 4*sqrt(2), -6 + 4*sqrt(2) }

> s;
{{ x = -2*sqrt(2), y = -2*sqrt(2), z = 4*sqrt(2) + 10 }, { x = 2*sqrt(2), y = 2*sqrt(2), z = -4*sqrt(2) + 10 }}
```

--------------------------------

### Maple: Leibniz Notation for Derivatives

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Explains how to use Leibniz notation for both univariate and multivariate derivatives in Maple. It includes examples of entering partial derivatives and using short-form notation.

```maple
diff(x^2 + x, x);
# Output: 2*x + 1

Diff(Diff(x^2 + x, x), x);
# Output: 2

Diff(Diff(x^2*y, x), y);
# Output: x^2

with(Typesetting):

Suppress(f, x, y);
# Output: ∂f/∂x

Settings(userep = true):

f,x,y;
# Output: f[x,y]
```

--------------------------------

### Explore Factoring Expression with Initial Values (Maple)

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=Explore

Shows how to use the Explore command to interactively explore the factoring of an expression (x^a - 1). The 'parameters' option defines the range for 'a', and 'initialvalues' sets the starting value for 'a'.

```maple
> Explore(factor(x^a - 1), parameters = a = 2..9, initialvalues = a = 4)
```

--------------------------------

### Compute Groebner Basis over Finite Fields in Maple

Source: https://www.maplesoft.com/support/help/Maple/view_path=Groebner

This example illustrates the computation of a Groebner basis over a finite field (modulo 5) using Maple's Groebner package. It shows how to specify the characteristic for modular arithmetic computations.

```maple
G := [x^2 - 2*x*z + 5, x*y^2 + y*z^3, 3*y^2 - 8*z^3]:
Gmod5;
Basis(G, plex(x, y, z), characteristic = 5);
```

--------------------------------

### Factor a polynomial over a specific number

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates factoring a polynomial where the second argument is a specific number. This implies factorization over a number field related to that number.

```maple
factor(x^3+5, 513)
```

--------------------------------

### Maple Type Checking Examples

Source: https://www.maplesoft.com/support/help/Maple/view_path=extension

These Maple snippets demonstrate various type checking scenarios using the 'type' command. They cover checking for standard integers, custom types defined within a module (FunnyIntegers), and correctly formatted integer strings.

```maple
type( 2, 'integer' );
```

```maple
type( 2, 'FunnyIntegers:-integer' );
```

```maple
type( 'INTEGER'( "3" ), 'integer' );
```

```maple
type( 'INTEGER'( "3" ), 'FunnyIntegers:-integer' );
```

```maple
'INTEGER'( "42" ); # printing works
```

```maple
with( FunnyIntegers );
```

```maple
type( 2, 'integer' ); # local type is now bound
```

```maple
type( 'INTEGER'( "3" ), 'integer' );
```

```maple
type( 'INTEGER'( "3" ), ':-integer' ); # global type is still accessible by using the :- prefix
```

--------------------------------

### Factor a polynomial over a radical

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates factoring a polynomial over an algebraic number field defined by a radical. The `factor` command uses the specified radical to extend the coefficient field.

```maple
factor(y^4-2, sqrt(2))
```

--------------------------------

### Factor a polynomial over complex numbers

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example shows factoring a polynomial over the complex numbers. The `factor` command, when given the keyword `complex`, performs a floating-point factorization over the complex field.

```maple
factor(x^3+5, complex)
```

--------------------------------

### Factor a polynomial over a complex radical extension

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example demonstrates factoring a polynomial over an algebraic extension defined by a complex radical. This showcases the command's ability to handle complex number fields for factorization.

```maple
factor(a, sqrt(2-2*I*sqrt(3)))
```

--------------------------------

### Factor a polynomial over a specific algebraic extension

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example shows factoring a polynomial over an algebraic extension defined by a specific number. This is useful for finding factors within a particular field.

```maple
factor(x^3+y^3, (-3)^(1/2))
```

--------------------------------

### Factor a polynomial over a RootOf object

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example shows factoring a polynomial over an algebraic number field defined by a `RootOf` object. The `factor` command uses the specified `RootOf` to extend the coefficient field.

```maple
alias(alpha=RootOf(x^2-2)):
factor(y^4-2, alpha)
```

--------------------------------

### Maple: Basic Arbitrary-Precision Integer Arithmetic

Source: https://www.maplesoft.com/support/help/Maple/view_cid=1425&path=examples%2FGMP

Illustrates basic arithmetic operations with very large integers in Maple, including factorials, exponentiation, finding the next prime, and calculating the greatest common divisor.

```maple
133!/2^31 + 141^41;

p := nextprime(%); # Find the smallest prime greater than the previous number
isprime(p);
igcd(p, 2*p); # Greatest common divisor of p and 2*p is p
```

--------------------------------

### Maple HFloat Function Examples

Source: https://www.maplesoft.com/support/help/Maple/view_path=HFloat

Demonstrates the usage of the HFloat function in Maple to represent hardware floating-point numbers. It shows how different numeric inputs are converted and displayed.

```maple
> HFloat(2.3)
2.30000000000000

> HFloat(2.)
2.

> HFloat(−0.3)
−0.300000000000000

> HFloat(−23000.)
−23000.

> ⋅120000.
−2.760000000×109

> type(,hfloat)
true
```

--------------------------------

### Maple: Get Maximum Hardware Integer Size

Source: https://www.maplesoft.com/support/help/Maple/view_cid=1425&path=examples%2FGMP

Retrieves the largest integer that can be represented by a hardware integer in Maple. This defines the boundary for when software integers (arbitrary-precision) are used.

```maple
kernelopts(maximmediate);
```

--------------------------------

### HTTP Package - Get Command

Source: https://www.maplesoft.com/support/help/Maple/view_path=HTTP

The `Get` command in the HTTP package is used to retrieve data from a specified URL.

```APIDOC
## GET /fetch

### Description
Fetches data from a given URL.

### Method
GET

### Endpoint
(This is a package command, not a REST endpoint)

### Parameters
#### Query Parameters
- **url** (string) - Required - The URL to fetch data from.

### Request Example
```
with(HTTP):
result := Get("http://www.maplesoft.com/")
```

### Response
#### Success Response (200)
- **response** (string) - The content of the HTTP response.
- **status_code** (integer) - The HTTP status code of the response (e.g., 200 for OK).

#### Response Example
```json
{
  "response": "<html>...</html>",
  "status_code": 200
}
```
```

--------------------------------

### Maple: Float Overflow Example

Source: https://www.maplesoft.com/support/help/Maple/view_path=float

Provides an example of floating-point overflow in Maple. The exp(1e100) function calculates the exponential of a very large number, resulting in an 'infinity' representation.

```maple
exp(1e100);
```

--------------------------------

### Inputting Special Functions using Command Completion

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Demonstrates how to use command completion to input special functions like BesselJ and BesselI. This method allows for textbook notation input by typing the function name and using completion.

```Maple
expr := BesselJ(v,x) + BesselI(v,x)
```

--------------------------------

### GegenbauerC Examples with Special Values

Source: https://www.maplesoft.com/support/help/Maple/view_path=GegenbauerC

Provides examples of using the simplify command with GegenbauerC for special values of n, including negative integers and zero, demonstrating the expected outputs.

```maple
simplify(GegenbauerC(n, a, z), 'GegenbauerC') assuming n::negint;
```

```maple
simplify(GegenbauerC(n, a, z), 'GegenbauerC') assuming n = 0;
```

```maple
simplify(GegenbauerC(3, a, z), 'GegenbauerC');
```

--------------------------------

### Maple Example: GCD Calculation Modulo 7

Source: https://www.maplesoft.com/support/help/Maple/view_path=Gcd

An example demonstrating the calculation of the greatest common divisor (GCD) of two simple linear polynomials modulo 7 in Maple.

```maple
Gcd(x+2, x+3) mod 7
```

--------------------------------

### Maple: Using Command-Symbol Completion for 2-D Operators

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

This example illustrates how to use Maple's command-symbol completion feature to insert mathematical operators like summation (∑) into 2-D math expressions. It shows two methods: one using keyboard shortcuts (Ctrl + ' for subscripts, Ctrl + Shift + " for superscripts) and another using Tab to navigate and fill placeholders.

```Maple
# Method 1: Using keyboard shortcuts
# To input: ∑_{i=1}^{n} i
# Steps:
# 1. Type 'sum' and use command completion to select ∑
# 2. Press Ctrl + ' and type 'i=1'
# 3. Use Right Arrow key to exit subscript
# 4. Press Ctrl + Shift + " and type 'n'
# 5. Use Right Arrow key to exit superscript
# 6. Type 'i'
# Result: ∑_{i=1}^{n} i

# Method 2: Using Tab to navigate placeholders
# To input: ∑_{i=1}^{n} i
# Steps:
# 1. Type 'sum' and use command completion to select ∑
# 2. Press Tab to move between placeholders and replace:
#    - Replace 'l' with 'i=1'
#    - Replace 'r' with 'n'
#    - Replace 'f' with 'i'
# Result: ∑_{i=1}^{n} i
```

--------------------------------

### Maple: Interface Settings for Numerical Output

Source: https://www.maplesoft.com/support/help/Maple/view_path=float

Demonstrates how to change interface settings in Maple. Setting prettyprint to 0 affects the output format of numerical expressions, often simplifying them.

```maple
interface(prettyprint=0);
```

--------------------------------

### Operator Precedence Example

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Compares the precedence of a non-equivalence operator ('⊠') with multiplication, showing how it affects the order of operations in an expression.

```Maple
a*b⊠c*d/a*d
```

```Maple
a*b + c*d/a*d
```

--------------------------------

### Entering Integrals in Maple

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Explains how to input definite integrals using command completion and special character entry for the differential 'd'. This method ensures correct mathematical notation for integration.

```maple
int 0..10 x * DifferentialD(x)
```

```maple
int(x*DifferentialD(x), x=0..10)
```

--------------------------------

### Maple Module for Extensible Facility Implementation

Source: https://www.maplesoft.com/support/help/Maple/view_path=extension

This Maple module, named 'Foo', implements an extensible facility. It exports 'AddFoo', 'GetFoo', and 'RemoveFoo' procedures to manage a local table 'fooTab'. The 'DoFoo' procedure applies specified transformations to expressions based on the registered extensions.

```maple
Foo := module()
export AddFoo, GetFoo, RemoveFoo;
local fooTab;
global DoFoo;

fooTab := table():

AddFoo := proc( theName::symbol, implementation )
local old_imp;
old_imp := NULL;
if assigned( fooTab[ theName ] ) then
WARNING( "replacing existing extension `%1'", theName );
old_imp := eval( fooTab[ theName ] )
end if;
fooTab[ theName ] := eval( implementation, 1 );
eval( old_imp, 1 )
end proc;

RemoveFoo := proc( theName::symbol )
if assigned( fooTab[ theName ] ) then
fooTab[ theName ] := evaln( fooTab[ theName ] )
end if;
NULL
end proc;

GetFoo := proc( theName::symbol )
if assigned( fooTab[ theName ] ) then
eval( fooTab[ theName ], 1 )
else
NULL
end if
end proc;

DoFoo := proc( expr, foo )
if assigned( fooTab[ foo ] ) then
subsindets( expr, 'specfunc'( 'anything', foo ), fooTab[ foo ] )
else
error "cannot do %1", foo
end if
end proc;

end module:
```

--------------------------------

### Maple: Setting Dot Notation for Output

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Demonstrates how to configure Maple to display derivatives using dot notation in the output, instead of the standard d/dt notation, using the Typesetting package.

```maple
with(Typesetting):

Settings(typesetdot = true):

f..;
# Output: f..(t)

y. + 3*y = 0;
# Output: y.(t) + 3*y(t) = 0
```

--------------------------------

### HermiteH Function

Source: https://www.maplesoft.com/support/help/Maple/view_path=HermiteH

Documentation for the HermiteH function, which computes Hermite polynomials and their analytic extensions. It includes details on parameters, mathematical properties, and examples.

```APIDOC
## HermiteH(n, x)

### Description
For a non-negative integer n, the HermiteH(n, x) function computes the nth Hermite polynomial. The Hermite polynomials are orthogonal on the interval (−∞,∞) with respect to the weight function w(x)=e−x2.

For n different from a non-negative integer, the analytic extension of the Hermite polynomial is given by:
HermiteH(n,x)=2^n * sqrt(pi) * (KummerM((-n)/2, 1/2, x^2) / Gamma(1/2 - n/2) - 2*x * KummerM(1/2 - n/2, 3/2, x^2) / Gamma(-n/2))

### Method
Computes Hermite polynomials and their analytic extensions.

### Parameters
#### Path Parameters
- **n** (algebraic expression) - Required - The order of the Hermite polynomial.
- **x** (algebraic expression) - Required - The variable for the Hermite polynomial.

### Request Example
```
HermiteH(3, x)
```

### Response
#### Success Response (200)
- **Result** (algebraic expression) - The computed Hermite polynomial or its analytic extension.

#### Response Example
```
HermiteH(3, x) = 8*x^3 - 12*x
HermiteH(3.2, 2.1) = 59.58210770
```
```

--------------------------------

### Maple: Plot Comparison Function

Source: https://www.maplesoft.com/support/help/Maple/view_path=fdiff

The 'plots[plotcompare]()' command is used for comparing plots. The provided text indicates its existence but does not include a specific usage example.

```Maple
plots[plotcompare]()
```

--------------------------------

### Create and Display Weight Matrix of Directed Graph in Maple

Source: https://www.maplesoft.com/support/help/Maple/view_path=GraphTheory

Shows how to define a weighted directed graph (network) and then display its corresponding weight matrix. The GraphTheory package must be loaded for these commands to function.

```maple
with(GraphTheory):

N := Digraph({[[1,2],3],[[1,3],3],[[2,4],4],[[3,4],4]})
WeightMatrix(N)
```

--------------------------------

### Handling Generalized Operators

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Demonstrates the parsing of MathML operators like '≪' into Maple functions and how to re-evaluate them. It also shows alternative input methods for operators like '≤'.

```Maple
expr := a << b;
```

```Maple
op(0, expr)
```

```Maple
eval(expr = a, b -> a + b);
```

```Maple
a <= x <= b
```

--------------------------------

### Maple: Differentiating Bessel Functions

Source: https://www.maplesoft.com/support/help/Maple/view_path=fdiff

Calculates the derivative of the BesselK function with respect to its argument 'a'. The example shows how to compute the derivative at a specific point (t1=0) and expand it as a series.

```Maple
ddaBesselK(a,35)=(
  ddt1BesselK(t1,35)
){
  t1 = 0
}
|
|
|
|
(ddt1BesselK(t1,35))
{
  t1 = 0
} +
(
  (
    d2dt12BesselK(t1,35)
  )
  {
    t1 = 0
  }
|
|
(
    d2dt12BesselK(t1,35)
  )
  {
    t1 = 0
  }
) a +
(
  (
    d3dt13BesselK(t1,35)
  )
  {
    t1 = 0
  }
|
|
|
|
(
    d3dt13BesselK(t1,35)
  )
  {
    t1 = 0
  }
) a^2 / 2 +
(
  (
    d4dt14BesselK(t1,35)
  )
  {
    t1 = 0
  }
|
|
|
|
(
    d4dt14BesselK(t1,35)
  )
  {
    t1 = 0
  }
) a^3 / 6 +
(
  (
    d5dt15BesselK(t1,35)
  )
  {
    t1 = 0
  }
|
|
|
|
(
    d5dt15BesselK(t1,35)
  )
  {
    t1 = 0
  }
) a^4 / 24 +
(
  (
    d6dt16BesselK(t1,35)
  )
  {
    t1 = 0
  }
|
|
|
|
(
    d6dt16BesselK(t1,35)
  )
  {
    t1 = 0
  }
) a^5 / 120
```

--------------------------------

### Maple: Basic Floating-Point and Variable Assignment

Source: https://www.maplesoft.com/support/help/Maple/view_path=float

Illustrates basic floating-point number representation and variable assignment in Maple. The example shows assigning a large negative number in scientific notation to a variable 'y'.

```maple
2.3;
```

```maple
y:= -2.3e4;
```

--------------------------------

### Entering Directional Limits in Maple

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Demonstrates how to input directional limits (e.g., x approaching 0 from the positive side) using both direct typing and command completion. This is essential for defining one-sided limits.

```maple
lim x->0+ 1/x
```

```maple
limit(x->0+ 1/x)
```

--------------------------------

### Maple Exponentiation and Root Operations

Source: https://www.maplesoft.com/support/help/Maple/view_cid=1444&path=arithop

Demonstrates the behavior of the exponentiation operator (^) and related functions like `root` and `surd` with positive and negative bases, and fractional exponents. Note the differences in output, especially with complex number results for negative bases. These operations are thread-safe as of Maple 15.

```Maple
> (1.5+2.5*I)^(3.5+4.5*I);
-0.2203847124+0.3457407884*I

> (-8.)^(1/3);
1.000000000+1.732050807*I

> (8)^(1/3); root(8, 3); surd(8, 3);
2
2
2

> (8.0)^(1/3); root(8.0, 3); surd(8.0, 3);
2.000000000
2.000000000
2.000000000

> (-8)^(1/3); root(-8, 3); surd(-8, 3);
(-8)^(1/3)
2*(-1)^(1/3)
-2

> (-8.0)^(1/3); root(-8.0, 3); surd(-8.0, 3);
1.000000000+1.732050807*I
1.000000000+1.732050807*I
-2.000000000
```

--------------------------------

### Maple: Logic Operators

Source: https://www.maplesoft.com/support/help/Maple/view_cid=22&path=worksheet%2Fdocumenting%2F2DMathDetails

Illustrates the definition and usage of standard and extended logical operators in Maple, including their symbolic representations and command completion shortcuts. It also mentions the difference between Logic package operators and top-level operators.

```maple
not a = not a
a nand b = not (a and b)
a nor b = not (a or b)
a implies b
a ⇒ b
not a
and(a, b)
or(a, b)
```

--------------------------------

### Factor a polynomial over a set of numbers

Source: https://www.maplesoft.com/support/help/Maple/view_path=factor

This example shows factoring a polynomial over an algebraic number field defined by a set of numbers. The `factor` command uses these numbers to extend the coefficient field for factorization.

```maple
factor(x^3+5, {513, (-3)^(1/2)})
```

--------------------------------

### Maple: Understanding User Profiles and Startup Code

Source: https://www.maplesoft.com/support/help/Maple/view_cid=450&path=worksheet%2Fdocumenting%2Fstartupcode

This details how commands from a User Profile's [MapleCode] section are integrated into the startup code region, executing before the worksheet's startup code. User Profile code is placed between specific comment markers. It is not recommended to edit these commands directly within the Startup Code Editor due to potential data loss or formatting issues.

```Maple
## BEGIN USER_PROFILE:
with(LinearAlgebra)
# Matrix variable assignment
# END USER_PROFILE:
```

--------------------------------

### Using Grading Package Commands - Maple

Source: https://www.maplesoft.com/support/help/Maple/view_path=Grading

Demonstrates the usage of commands within the Maple Grading package for creating and manipulating linear functions, retrieving their expressions and data points, and plotting them. It also shows how to grade one plot against another.

```Maple
with(Grading):

L1 := LinearFunction(3*x - 4)
L2 := LinearFunction([0, -4], [4, 7.97])

GetExpression(L1)
GetData(L2)

plotview := [-10..10, -10..10]
Draw(L1, plotview)

GradePlot(L1, L2, plotview)
```
Tokens:
Raw