Maple Questions and Posts

These are Posts and Questions associated with the product, Maple

This came up in another language. I tried to solve it in Maple, but I am newbie so did not know how to.

The problem is to remove all products of  "a^n*b^m" that shows up in an expression, including any powers of "n,m". For example, given these three expressions

f0 := a^4+4*a^3*b +6*a^2*b^2+4*a*b^3+ b^4;
f1 := 3*(a*b -2*c);
f2 := (a*b -2*c)/(c - a*b);

Then applying the transformation needed, will result in

f0:= a^4+b^4;
f1:=-6*c;
f2:=-2;

Becuase the transformation will detect any a^n*b^m and simply replace this product by zero
from the resulting expression. So "a*b^2 + 2" will become "2", and so on.

I assume a function such as "patmatch" or "match" is needed. I tried, but could not figure how.
I also tried algsubs. How would this be coded in Maple?


Hi,

1st post. I'm trying to integrate the following function:

h:=t->(2*t-1)*cos*sqrt(3*(2*t-1)^2+6)/(sqrt(3*(2*t-1)^2+6));

h:=t->(2*t-1)*cos*(sqrt(3*(2*t-1)^2+6))/(sqrt(3*(2*t-1)^2+6));

h:=t->(2*t-1)*(cos*(sqrt(3*(2*t-1)^2+6)))/(sqrt(3*(2*t-1)^2+6));

h:=t->((2*t-1)*(cos*(sqrt(3*(2*t-1)^2+6))))/(sqrt(3*(2*t-1)^2+6));

int(h(t),t); ** Integration command. I've also replaced the "h(t)" with the entire function.

I've tried the following:

1. Changed the "t" to "x" throughout function.

2. Added parens around sqrt portion.

3. Added parens to include "cos" and then added to include the beginning (2*t-1).

4. I've added brackets around the numerator but this just causes Maple to reprint the function with the inegration sign in front of the function.

5. I've also tried using the Integration tutor. It returns that maple is unable to calculate.

6. Repeat all the above in Maple 2015, same answer.

I always get cos(t^2-t).

The math book claims the answer is 1/6*sin*sqrt(3*(2*t-1)^2+6). When I perform the inegration on paper I get the same answer.

Any suggestions or corrections would be great.

Thank you,

Jay.

 

hi every one...

how i can simplify this result (R_arm_F2 $  Twflex) via tringular relations.

where Ixflex & tetadot and other... are constants

thanks

matrix_f.mw


NULL

NULL

R := (Matrix(3, 3, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = cos(teta), (2, 3) = -sin(teta), (3, 1) = 0, (3, 2) = sin(teta), (3, 3) = cos(teta)})).(Matrix(3, 3, {(1, 1) = cos(phi), (1, 2) = 0, (1, 3) = sin(phi), (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (3, 1) = -sin(phi), (3, 2) = 0, (3, 3) = cos(phi)})).(Matrix(3, 3, {(1, 1) = cos(si), (1, 2) = -sin(si), (1, 3) = 0, (2, 1) = sin(si), (2, 2) = cos(si), (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = 1}))

R := Matrix(3, 3, {(1, 1) = cos(phi)*cos(si), (1, 2) = -cos(phi)*sin(si), (1, 3) = sin(phi), (2, 1) = sin(teta)*sin(phi)*cos(si)+cos(teta)*sin(si), (2, 2) = -sin(teta)*sin(phi)*sin(si)+cos(teta)*cos(si), (2, 3) = -sin(teta)*cos(phi), (3, 1) = -cos(teta)*sin(phi)*cos(si)+sin(teta)*sin(si), (3, 2) = cos(teta)*sin(phi)*sin(si)+sin(teta)*cos(si), (3, 3) = cos(teta)*cos(phi)})

(1)

NULL

RT := simplify(1/R)

RT := Matrix(3, 3, {(1, 1) = cos(phi)*cos(si), (1, 2) = sin(teta)*sin(phi)*cos(si)+cos(teta)*sin(si), (1, 3) = -cos(teta)*sin(phi)*cos(si)+sin(teta)*sin(si), (2, 1) = -cos(phi)*sin(si), (2, 2) = -sin(teta)*sin(phi)*sin(si)+cos(teta)*cos(si), (2, 3) = cos(teta)*sin(phi)*sin(si)+sin(teta)*cos(si), (3, 1) = sin(phi), (3, 2) = -sin(teta)*cos(phi), (3, 3) = cos(teta)*cos(phi)})

(2)

R_I_F2 := Matrix(3, 3, {(1, 1) = sin(phi)^2.(1-cos(si))+cos(si), (1, 2) = -(sin(phi).cos(phi).sin(teta))*(1-cos(si))-cos(phi).cos(teta).sin(si), (1, 3) = (sin(phi).cos(phi).cos(teta))*(1-cos(si))-sin(teta)*cos(phi).sin(si), (2, 1) = -(2*sin(phi).cos(phi).sin(teta).cos(teta))*(1-cos(si))+(cos(phi).sin(si))*(cos(teta)^2-sin(teta)^2), (2, 2) = (2*cos(phi)^2.(sin(teta)^2).cos(teta))*(1-cos(si))+cos(teta).cos(si)-sin(teta).sin(phi).sin(si), (2, 3) = -(2*cos(phi)^2.sin(teta))*cos(teta)^2*(1-cos(si))-sin(phi).cos(teta).sin(si)-sin(teta).cos(si), (3, 1) = (sin(phi).cos(phi))*(1-cos(si))*(cos(teta)^2-sin(teta)^2)+2*cos(phi).cos(teta).sin(teta).sin(si), (3, 2) = (cos(phi)^2.sin(teta))*(sin(teta)^2-cos(teta)^2)*(1-cos(si))+cos(si).sin(teta)+sin(phi).cos(teta).sin(si), (3, 3) = (cos(phi)^2.cos(teta))*(cos(teta)^2-sin(teta)^2)*(1-cos(si))-sin(phi).sin(teta).sin(si)+cos(teta).cos(si)})

R_I_F2 := Matrix(3, 3, {(1, 1) = sin(phi)^2.(1-cos(si))+cos(si), (1, 2) = -(`.`(sin(phi), cos(phi), sin(teta)))*(1-cos(si))-`.`(cos(phi), cos(teta), sin(si)), (1, 3) = (`.`(sin(phi), cos(phi), cos(teta)))*(1-cos(si))-sin(teta)*cos(phi).sin(si), (2, 1) = -2*(sin(phi).cos(phi).sin(teta).cos(teta))*(1-cos(si))+(cos(phi).sin(si))*(cos(teta)^2-sin(teta)^2), (2, 2) = 2*(cos(phi)^2.(sin(teta)^2).cos(teta))*(1-cos(si))+cos(teta).cos(si)-`.`(sin(teta), sin(phi), sin(si)), (2, 3) = -2*(cos(phi)^2.sin(teta))*cos(teta)^2*(1-cos(si))-`.`(sin(phi), cos(teta), sin(si))-sin(teta).cos(si), (3, 1) = (sin(phi).cos(phi))*(1-cos(si))*(cos(teta)^2-sin(teta)^2)+2*(cos(phi).cos(teta).sin(teta).sin(si)), (3, 2) = (cos(phi)^2.sin(teta))*(sin(teta)^2-cos(teta)^2)*(1-cos(si))+cos(si).sin(teta)+`.`(sin(phi), cos(teta), sin(si)), (3, 3) = (cos(phi)^2.cos(teta))*(cos(teta)^2-sin(teta)^2)*(1-cos(si))-`.`(sin(phi), sin(teta), sin(si))+cos(teta).cos(si)})

(3)

NULL

R_arm_F2 := RT.R_I_F2

R_arm_F2 := Matrix(3, 3, {(1, 1) = cos(phi)*cos(si)*(sin(phi)^2.(1-cos(si))+cos(si))+(sin(teta)*sin(phi)*cos(si)+cos(teta)*sin(si))*(-2*(`.`(sin(phi), cos(phi), sin(teta), cos(teta)))*(1-cos(si))+(cos(phi).sin(si))*(cos(teta)^2-sin(teta)^2))+(-cos(teta)*sin(phi)*cos(si)+sin(teta)*sin(si))*((sin(phi).cos(phi))*(1-cos(si))*(cos(teta)^2-sin(teta)^2)+2*(`.`(cos(phi), cos(teta), sin(teta), sin(si)))), (1, 2) = cos(phi)*cos(si)*(-(`.`(sin(phi), cos(phi), sin(teta)))*(1-cos(si))-`.`(cos(phi), cos(teta), sin(si)))+(sin(teta)*sin(phi)*cos(si)+cos(teta)*sin(si))*(2*(`.`(cos(phi)^2, sin(teta)^2, cos(teta)))*(1-cos(si))+cos(teta).cos(si)-`.`(sin(teta), sin(phi), sin(si)))+(-cos(teta)*sin(phi)*cos(si)+sin(teta)*sin(si))*((cos(phi)^2.sin(teta))*(sin(teta)^2-cos(teta)^2)*(1-cos(si))+cos(si).sin(teta)+`.`(sin(phi), cos(teta), sin(si))), (1, 3) = cos(phi)*cos(si)*((`.`(sin(phi), cos(phi), cos(teta)))*(1-cos(si))-sin(teta)*cos(phi).sin(si))+(sin(teta)*sin(phi)*cos(si)+cos(teta)*sin(si))*(-2*(cos(phi)^2.sin(teta))*cos(teta)^2*(1-cos(si))-`.`(sin(phi), cos(teta), sin(si))-sin(teta).cos(si))+(-cos(teta)*sin(phi)*cos(si)+sin(teta)*sin(si))*((cos(phi)^2.cos(teta))*(cos(teta)^2-sin(teta)^2)*(1-cos(si))-`.`(sin(phi), sin(teta), sin(si))+cos(teta).cos(si)), (2, 1) = -cos(phi)*sin(si)*(sin(phi)^2.(1-cos(si))+cos(si))+(-sin(teta)*sin(phi)*sin(si)+cos(teta)*cos(si))*(-2*(`.`(sin(phi), cos(phi), sin(teta), cos(teta)))*(1-cos(si))+(cos(phi).sin(si))*(cos(teta)^2-sin(teta)^2))+(cos(teta)*sin(phi)*sin(si)+sin(teta)*cos(si))*((sin(phi).cos(phi))*(1-cos(si))*(cos(teta)^2-sin(teta)^2)+2*(`.`(cos(phi), cos(teta), sin(teta), sin(si)))), (2, 2) = -cos(phi)*sin(si)*(-(`.`(sin(phi), cos(phi), sin(teta)))*(1-cos(si))-`.`(cos(phi), cos(teta), sin(si)))+(-sin(teta)*sin(phi)*sin(si)+cos(teta)*cos(si))*(2*(`.`(cos(phi)^2, sin(teta)^2, cos(teta)))*(1-cos(si))+cos(teta).cos(si)-`.`(sin(teta), sin(phi), sin(si)))+(cos(teta)*sin(phi)*sin(si)+sin(teta)*cos(si))*((cos(phi)^2.sin(teta))*(sin(teta)^2-cos(teta)^2)*(1-cos(si))+cos(si).sin(teta)+`.`(sin(phi), cos(teta), sin(si))), (2, 3) = -cos(phi)*sin(si)*((`.`(sin(phi), cos(phi), cos(teta)))*(1-cos(si))-sin(teta)*cos(phi).sin(si))+(-sin(teta)*sin(phi)*sin(si)+cos(teta)*cos(si))*(-2*(cos(phi)^2.sin(teta))*cos(teta)^2*(1-cos(si))-`.`(sin(phi), cos(teta), sin(si))-sin(teta).cos(si))+(cos(teta)*sin(phi)*sin(si)+sin(teta)*cos(si))*((cos(phi)^2.cos(teta))*(cos(teta)^2-sin(teta)^2)*(1-cos(si))-`.`(sin(phi), sin(teta), sin(si))+cos(teta).cos(si)), (3, 1) = sin(phi)*(sin(phi)^2.(1-cos(si))+cos(si))-sin(teta)*cos(phi)*(-2*(`.`(sin(phi), cos(phi), sin(teta), cos(teta)))*(1-cos(si))+(cos(phi).sin(si))*(cos(teta)^2-sin(teta)^2))+cos(teta)*cos(phi)*((sin(phi).cos(phi))*(1-cos(si))*(cos(teta)^2-sin(teta)^2)+2*(`.`(cos(phi), cos(teta), sin(teta), sin(si)))), (3, 2) = sin(phi)*(-(`.`(sin(phi), cos(phi), sin(teta)))*(1-cos(si))-`.`(cos(phi), cos(teta), sin(si)))-sin(teta)*cos(phi)*(2*(`.`(cos(phi)^2, sin(teta)^2, cos(teta)))*(1-cos(si))+cos(teta).cos(si)-`.`(sin(teta), sin(phi), sin(si)))+cos(teta)*cos(phi)*((cos(phi)^2.sin(teta))*(sin(teta)^2-cos(teta)^2)*(1-cos(si))+cos(si).sin(teta)+`.`(sin(phi), cos(teta), sin(si))), (3, 3) = sin(phi)*((`.`(sin(phi), cos(phi), cos(teta)))*(1-cos(si))-sin(teta)*cos(phi).sin(si))-sin(teta)*cos(phi)*(-2*(cos(phi)^2.sin(teta))*cos(teta)^2*(1-cos(si))-`.`(sin(phi), cos(teta), sin(si))-sin(teta).cos(si))+cos(teta)*cos(phi)*((cos(phi)^2.cos(teta))*(cos(teta)^2-sin(teta)^2)*(1-cos(si))-`.`(sin(phi), sin(teta), sin(si))+cos(teta).cos(si))})

(4)

Twflex := Typesetting:-delayDotProduct(Ixflex, (Typesetting:-delayDotProduct(tetadot, Typesetting:-delayDotProduct(sin(phi)^2, 1-cos(si))+cos(si))+Typesetting:-delayDotProduct(sidot, sin(phi)^3+Typesetting:-delayDotProduct(cos(phi)^2, Typesetting:-delayDotProduct(sin(phi), cos(si)+Typesetting:-delayDotProduct(cos(teta), 1-cos(si)))+Typesetting:-delayDotProduct(sin(teta), sin(si)))))^2)

Ixflex.((tetadot.(sin(phi)^2.(1-cos(si))+cos(si))+sidot.(sin(phi)^3+cos(phi)^2.(sin(phi).(cos(si)+cos(teta).(1-cos(si)))+sin(teta).sin(si))))^2)

(5)

simplify(Twflex)

Ixflex.((tetadot.(sin(phi)^2.(1-cos(si))+cos(si))+sidot.(-sin(phi)*cos(phi)^2+sin(phi)+cos(phi)^2.(sin(phi).(cos(si)+cos(teta).(1-cos(si)))+sin(teta).sin(si))))^2)

(6)

expand(Twflex)

Ixflex.((tetadot.(sin(phi)^2.(1-cos(si))+cos(si))+sidot.(sin(phi)^3+cos(phi)^2.(sin(phi).(cos(si)+cos(teta).(1-cos(si)))+sin(teta).sin(si))))^2)

(7)

``

NULL


Download matrix_f.mw

updated:

with(CurveFitting);
f := PolynomialInterpolation([[0, x0],[1, x1],[2, x2],[3, x3],[4, x4]], x);
f2 := solve(f=y,x);
area1 := int(f, x=0..1);
with(student):
area2 := trapezoid(f2[1], x = 0..1);
with(CurveFitting);
f := PolynomialInterpolation([[0, x0],[1, x1],[2, x2],[3, x3]], x);
f2 := solve(f=y,x);
area1 := int(f, x=0..1);
with(student):
area2 := trapezoid(f2[1], x = 0..1);

 

i use 5 points trapezoid got RootOf  in result,

only 4 points is acceptable

 

when i try 5 points, there is no problem, but when more points such as

30 points, got RootOf for c sharp code

 

moreover, i got a problem when i copy the area1 result into 

visual studio c# code, it has error Integral Constant is too large

 

with(CurveFitting);
f := PolynomialInterpolation([[0, x0],[1, x1],[2, x2],[3, x3],[4, x4],[5, x5],[6, x6],[7, x7],[8, x8],[9, x9],[10, x10],[11, x11],[12, x12],[13, x13],[14, x14],[15, x15],[16, x16],[17, x17],[18, x18],[19, x19],[20, x20],[21, x21],[22, x22],[23, x23],[24, x24],[25, x25],[26, x26],[27, x27],[28, x28],[29, x29]], x);
f2 := solve(f=y,x);
area1 := int(f, y=0..1);
with(student):
area2 := trapezoid(f2[1], x = 0..1);
with(CodeGeneration):
CSharp(area1, resultname = "area1");
CSharp(area2, resultname = "area2");

i find area2 has

Warning, the function names {RootOf, Sum} are not recognized in the target language
Warning, precedence for Range unspecified
Warning, cannot translate range
area2 = RootOf((System.Double) (19276689540529530246975515949293568 * x3 - 2626509155780373903082144116707328 * x2 + 239680950855919251544490932629504 * x1 -

Hi,

I am trying to solve a set of homogeneous equations for the non-trivial solutions. Mathematically it is possible to get it. But is there any way to get it in Maple. Please find the attached maple sheet for the question. Please help me regarding this.

Regards

Sunit

restart

with(plots):

with(LinearAlgebra):

eq[1] := diff(x[1](t), t)-x[2](t)

diff(x[1](t), t)-x[2](t)

(1)

eq[2] := diff(x[2](t), t)+2*zeta*beta*x[2](t)+beta^2*x[1](t)+n*psi*(-v*(phi[1](t)-phi[1](t-2*Pi/(n*omega0)))+x[1](t)-x[1](t-2*Pi/(n*omega0)))

diff(x[2](t), t)+2*zeta*beta*x[2](t)+beta^2*x[1](t)+n*psi*(-v*(phi[1](t)-phi[1](t-2*Pi/(n*omega0)))+x[1](t)-x[1](t-2*Pi/(n*omega0)))

(2)

eq[3] := diff(phi[1](t), t)-phi[2](t)

diff(phi[1](t), t)-phi[2](t)

(3)

eq[4] := diff(phi[2](t), t)+2*kappa*phi[2](t)+phi[1](t)+n*(-v*(phi[1](t)-phi[1](t-2*Pi/(n*omega0)))+x[1](t)-x[1](t-2*Pi/(n*omega0)))

diff(phi[2](t), t)+2*kappa*phi[2](t)+phi[1](t)+n*(-v*(phi[1](t)-phi[1](t-2*Pi/(n*omega0)))+x[1](t)-x[1](t-2*Pi/(n*omega0)))

(4)

for k to 4 do eqn[k] := simplify(coeff(map(expand, eval(eq[k], [x[1] = (proc (t) options operator, arrow; x[1]*exp(lambda*t) end proc), x[2] = (proc (t) options operator, arrow; x[2]*exp(lambda*t) end proc), phi[1] = (proc (t) options operator, arrow; phi[1]*exp(lambda*t) end proc), phi[2] = (proc (t) options operator, arrow; phi[2]*exp(lambda*t) end proc)])), exp(lambda*t))) end do

x[1]*lambda-x[2]

 

x[2]*lambda+2*zeta*beta*x[2]+beta^2*x[1]-n*psi*v*phi[1]+n*psi*v*phi[1]*exp(-2*lambda*Pi/(n*omega0))+n*psi*x[1]-n*psi*x[1]*exp(-2*lambda*Pi/(n*omega0))

 

phi[1]*lambda-phi[2]

 

phi[2]*lambda+2*kappa*phi[2]+phi[1]-n*v*phi[1]+n*v*phi[1]*exp(-2*lambda*Pi/(n*omega0))+n*x[1]-n*x[1]*exp(-2*lambda*Pi/(n*omega0))

(5)

A, b := GenerateMatrix([seq(eqn[k], k = 1 .. 4)], [x[1], x[2], phi[1], phi[2]])

A, b := Matrix(4, 4, {(1, 1) = lambda, (1, 2) = -1, (1, 3) = 0, (1, 4) = 0, (2, 1) = beta^2+n*psi-n*psi*exp(-2*lambda*Pi/(n*omega0)), (2, 2) = 2*Zeta*beta+lambda, (2, 3) = n*psi*v*exp(-2*lambda*Pi/(n*omega0))-n*psi*v, (2, 4) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = lambda, (3, 4) = -1, (4, 1) = n-n*exp(-2*lambda*Pi/(n*omega0)), (4, 2) = 0, (4, 3) = -n*v+1+n*v*exp(-2*lambda*Pi/(n*omega0)), (4, 4) = 2*kappa+lambda}), Vector(4, {(1) = 0, (2) = 0, (3) = 0, (4) = 0})

(6)

right_vector := Matrix(4, 1, [r[1], r[2], r[3], r[4]])

right_vector := Matrix(4, 1, {(1, 1) = r[1], (2, 1) = r[2], (3, 1) = r[3], (4, 1) = r[4]})

(7)

junk := MatrixVectorMultiply(subs(lambda = I*omega, A), right_vector)

junk := Matrix(4, 1, {(1, 1) = I*omega*r[1]-r[2], (2, 1) = (beta^2+n*psi-n*psi*exp(-(2*I)*omega*Pi/(n*omega0)))*r[1]+(2*Zeta*beta+I*omega)*r[2]+(n*psi*v*exp(-(2*I)*omega*Pi/(n*omega0))-n*psi*v)*r[3], (3, 1) = I*omega*r[3]-r[4], (4, 1) = (n-n*exp(-(2*I)*omega*Pi/(n*omega0)))*r[1]+(-n*v+1+n*v*exp(-(2*I)*omega*Pi/(n*omega0)))*r[3]+(2*kappa+I*omega)*r[4]})

(8)

junk(1)

I*omega*r[1]-r[2]

(9)

for k to 4 do eqnn[k] := junk(k) end do

I*omega*r[1]-r[2]

 

(beta^2+n*psi-n*psi*exp(-(2*I)*omega*Pi/(n*omega0)))*r[1]+(2*zeta*beta+I*omega)*r[2]+(n*psi*v*exp(-(2*I)*omega*Pi/(n*omega0))-n*psi*v)*r[3]

 

I*omega*r[3]-r[4]

 

(n-n*exp(-(2*I)*omega*Pi/(n*omega0)))*r[1]+(1-n*v+n*v*exp(-(2*I)*omega*Pi/(n*omega0)))*r[3]+(2*kappa+I*omega)*r[4]

(10)

solve({seq(eqnn[k], k = 1 .. 4)}, {seq(r[k], k = 1 .. 4)})

{r[1] = 0, r[2] = 0, r[3] = 0, r[4] = 0}

(11)

``

``

``

 

Download question4.mw

A prime producing polynomial.

 

Observations on the trinomial n2 + n + 41.

 

by Matt C. Anderson

 

September 3, 2016

 

The story so far

 

We assume that n is an integer.  We focus our attention on the polynomial n^2 + n + 41.

 

Furthur, we analyze the behavior of the factorization of integers of the form

 

h(n) = n2 + n + 41                                          (expression 1)

 

where n is a non-negative integer.  It was shown by Legendre, in 1798 that if 0 ≤ n < 40 then h(n) is a prime number.

 

Certain patterns become evident when considering points (a,n) where

 

h(n) ≡ 0 mod a.                                             (expression 2)

 

The collection of all such point produces what we are calling a "graph of discrete divisors" due to certain self-similar features.  From experimental data we find that the integer points in this bifurcation graph lie on a collection of parabolic curves indexed by pairs of relatively prime integers.  The expression for the middle parabolas is –

 

p(r,c) = (c*x – r*y)2 – r*(c*x – r*y) – x + 41*r2.           (expression 3)

 

The restrictions are that 0<r<c and gcd(r,c) = 1 and all four of r,c,x, and y are integers.

 

Each such pair (r,c) yields (again determined experimentally and by observation of calculations) an integer polynomial a*z2 + b*z + c, and the quartic h(a*z2 + b*z + c) then factors non-trivially over the integers into two quadratic expressions.  We call this our "parabola conjecture".  Certain symmetries in the bifurcation graph are due to elementary relationships between pairs of co-prime integers.  For instance if m<n are co-prime integers, then there is an observable relationship between the parabola it determines that that formed from (n-m, n).

 

We conjecture that all composite values of h(n) arise by substituting integer values of z into h(a*z2 + b*z + c), where this quartic factors algebraically over Z for a*z2 + b*z + c a quadratic polynomial determined by a pair of relatively prime integers.  We name this our "no stray points conjecture" because all the points in the bifurcation graph appear to lie on a parabola.

 

We further conjecture that the minimum x-values for parabolas corresponding to (r, c) with gcd(r, c) = 1 are equal for fixed n.  Further, these minimum x-values line up at 163*c^2/4 where c = 2, 3, 4, ...  The numerical evidence seems to support this.  This is called our "parabolas line up" conjecture.

 

The notation gcd(r, c) used above is defined here.  The greatest common devisor of two integers is the smallest whole number that divides both of those integers.

 

Theorem 1 - Consider h(n) with n a non negative integer. 

h(n) never has a factor less than 41.

 

We prove Theorem 1 with a modular construction.  We make a residue table with all the prime factors less than 41.  The fundamental theorem of arithmetic states that any integer greater than one is either a prime number, or can be written as a unique product of prime numbers (ignoring the order).  So if h(n) never has a prime factor less than 41, then by extension it never has an integer factor less than 41.

 

For example, to determine that h(n) is never divisible by 2, note the first column of the residue table.  If n is even, then h(n) is odd.  Similarly, if n is odd then h(n) is also odd.  In either case, h(n) does not have factorization by 2.

 

Also, for divisibility by 3, there are 3 cases to check.  They are n = 0, 1, and 2 mod 3. h(0) mod 3 is 2.  h(1) mod 3 is 1. and h(2) mod 3 is 2.  Due to these three cases, h(n) is never divisible by 3.  This is the second column of the residue table.

 

The number 0 is first found in the residue table for the cases h(0) mod 41 and h(40) mod 41.  This means that if n is congruent to 0 mod 41 then h(n) will be divisible by 41.  Similarly, if n is congruent to 40 mod 41 then h(n) is also divisible by 41.

After the residue table, we observe a bifurcation graph which has points when h(y) mod x is divisible by x.  The points (x,y) can be seen on the bifurcation graph.

 

< insert residue table here >

 

Thus we have shown that h(n) never has a factor less than 41.

 

Theorem 2

 

Since h(a) = a^2 + a + 41, we want to show that h(a) = h( -a -1).

 

Proof of Theorem 2

Because h(a) = a*(a+1) + 41,

Now h(-a -1) = (-a -1)*(-a -1 +1) + 41.

So h(-a -1) = (-a -1)*(-a) +41,

And h(-a -1) = h(a).

Which was what we wanted.

End of proof of theorem 2.

 

Corrolary 1

Further, if h(b) mod c ≡ = then h(c –b -1) mod c ≡ 0.

 

We can observe interesting patterns in the “graph of discrete divisors” on a following page.

 

Hello all..

Im sharena and i am solving ODE BVP by using maple. i used this command to solved the equation..

 

However, i dont know which method this programm solved my ODE. Is it RK45 method??

Walking into the big blue Maplesoft office on August 3rd was a bit nerve wracking. I had no idea who anyone was, what to expect, or even what I would be doing. As I sat in the front hall waiting for someone to receive me, I remember thinking, “What have I gotten myself into?”. Despite my worries on that first day, interning at Maplesoft has been a great experience! I never knew that I would be able to learn so much about programming and working in a company in such a short amount of time. Although Maple was a programming language that was foreign to me a couple weeks ago, I feel like I’m relatively well versed in it now. Trying to learn a new language in this short timespan hasn’t been easy, but I think that I picked it up quickly, even if I’ve had my fair share of frustrations.

Chaos Game example on Rosetta Code

At Maplesoft, I’ve been contributing to the Rosetta Code project by writing short programs using Maple. The Rosetta Code project is dedicated to creating programming examples for many different tasks in different programming languages. My summer project has been to create solutions using Maple for as many tasks as possible and to post these to Rosetta Code; the goal being to have the list of tasks without Maple implementation shrink with each passing day. It’s nice to feel like I’m leaving a mark in this world, even if it is in such a small corner of the internet.

Flipping Bits example on Rosetta Code/MapleCloud

This internship, of course, came with its share of challenges. During my work on the Rosetta Code project, I posted solutions for a total of 38 tasks. Some of them were easy, but some of them took days to complete. On some days, I felt like I was on top of the world. Everything I made turned out great and I knew exactly how to tackle each problem. Other days were slower. I’ve spent ages just staring at a computer monitor trying to figure out just how on earth I was going to make this machine do what I wanted it to do! The 24 Game task was particularly hard, but also very educational. Through this task, I learned about modules, a concept previously unknown to me. I’m fairly sure that the 24 Game also took me the longest, whereas the Increment a numerical string task took me no time at all. Despite it being easy, the Increment a numerical string task wasn’t particularly fun; a bit of a challenge is required for something to be entertaining, after all. My personal favourite was the Fibonacci n-step number sequences task. It was the first really challenging task I encountered, and for after which the feeling of finally completing a task that I spent so long on, of finally overcoming that mountain, was extremely satisfying. Not all challenges end in satisfaction, however. I often found myself accidentally doing something that made the window freeze. I would close the program, then cry a bit on the inside when I realized I just lost the past half an hour’s worth of unsaved work. Nevertheless, I’m glad I got to face all these obstacles because they have made me more resilient and a better programmer.

The following is the code for the Fibonacci n-step number sequences task

numSequence := proc(initValues :: Array)
	local n, i, values;
n := numelems(initValues);
values := copy(initValues);
for i from (n+1) to 15 do
values(i) := add(values[i-n..i-1]);
end do;
return values;
end proc:
 
initValues := Array([1]):
for i from 2 to 10 do
initValues(i) := add(initValues):
printf ("nacci(%d): %a\n", i, convert(numSequence(initValues), list));
end do:
printf ("lucas: %a\n", convert(numSequence(Array([2, 1])), list));

Maple was a great software to program with and a fairly straightforward language to learn. Having previously programmed in Java, I found Maple similar enough that transitioning wasn’t too difficult. In fact, every once in a while when I didn`t know what to do for a task, I would take a look at the Java example in Rosetta Code and it would point me in a direction or give me some hints. While the two languages are similar, there are still many differences. For example, I liked the fact that in Maple, lists started at an index of 1 rather than 0 and arrays could an arbitrary starting index. Although it was different from what I was used to, I found that it made many things much less confusing. Another thing I liked was that the for loop syntax was very simple. I never once had to run through in my head how many times something would loop for. There were such a wide variety of commands in Maple. There was a command for practically anything, and if you knew that it existed and how to use it, then so much power could be at your fingertips. This is where the help system came in extremely handy. With a single search you might find that the solution to the exact problem you were trying to solve already existed as a Maple command. I always had a help window open when I was using Maple.

Multiplication Tables example on Rosetta Code

Spending my summer coding at Maplesoft has been fun, sometimes challenging, but an overall rewarding experience. Through contributing to the Rosetta Code project, I’ve learned so much about computer programming, and it certainly made the 45 minute drive out to Waterloo worth it!

Yili Xu,
Maplesoft SHAD Intern

Hello Everyone,

May I ask you about this  "Error,   (in pdsolve/numeric/process_PDEs)  number of dependent variables and number of PDE must be the same". Does anyone have idea about solving linear instability equation (flow inside pipe, oscillating flow) ?

Thank you,

 

 

 

Hello, I need help in add/sum, there are two problems:

 

1. How we write triple summation (sigma) in Maple? (See pic)

Pic 1 (Triple Sigma)

I try sum(sum(sum or add(add(add but it isn't working.

 

 

2. How we write summation like in this pic?

Pic 2

I already try these syntax:

for e from 1 to 9 do

for k from 1 to 17 do

if i=(2*e-1) then next else

constraint12[2*e-1,k]:=add(x[2*e-1,i,k],i from i in T)=1

end if

end do

end do

 

For example, the expected result for e=2 and k=1 is like following equation:

x[2,1,1]+x[2,3,1]+x[2,4,1]+x[2,5,1]+...+x[2,17,1]+x[2,18,1]=1

But the result I get:

x[2,1,1]+x[2,2,1]+x[2,3,1]+...+x[2,18,1]=1

 

How to omit the x[2,2,1]?

 

Thank you.

pls help review this code, its doesnt return a solution

 

 

restart;
Digits := 16;
M := .5; lambda := .5; Pr := .72; beta := 1; L[w] := 0; m := 1; R := 1; Ec := 1;
N := 7;
for j from 0 to N do J[j] := sum(f[k](t)*(diff(f[j-k](t), `$`(t, 2))), k = 0 .. j) end do;
for i from 0 to N do K[i] := sum((diff(f[k](t), t))*(diff(f[i-k](t), t)), k = 0 .. i) end do;
for j from 0 to N do G[j] := sum(f[k](t)*(diff(theta[j-k](t), t)), k = 0 .. j) end do;
for j from 0 to N do H[j] := sum((diff(f[k](t), t))*theta[j-k](t), k = 0 .. j) end do;
for i from 0 to N do P[i] := sum((diff(f[k](t), t, t))*(diff(f[i-k](t), t)), k = 0 .. i) end do;
epsilon := 1; delta := 0;
f[0] := proc (t) options operator, arrow; L[w]+epsilon+delta*A*t+(1/2)*A*t^2 end proc;
1 2
t -> L[w] + epsilon + delta A t + - A t
2
theta[0] := proc (t) options operator, arrow; 1+B*t end proc;
t -> 1 + B t
NULL;
;
NULL;
NULL;
NULL;
NULL;
for i to N do f[i] := simplify(-((m+1)*(1/2))*(int(int(int(J[i-1], t = 0 .. eta), t = 0 .. eta), t = 0 .. eta))+m*(int(int(int(1-K[i-1], t = 0 .. eta), t = 0 .. eta), t = 0 .. eta))-M*(int(int(int(diff(f[i-1](t), t)-1, t = 0 .. eta), t = 0 .. eta), t = 0 .. eta))-lambda*(int(int(int(theta[i-1](t), t = 0 .. eta), t = 0 .. eta), t = 0 .. eta))); f[i] := unapply(f[i], eta); theta[i] := simplify(-3*Pr*R*(((m+1)*(1/2))*(int(int(G[i-1], t = 0 .. eta), t = 0 .. eta))-(2*m-1)*(int(int(H[i-1], t = 0 .. eta), t = 0 .. eta))+Ec*(int(int(P[i-1], t = 0 .. eta), t = 0 .. eta)))/(4+3*R)); theta[i] := unapply(theta[i], eta) end do;
NULL;
F(eta):=collect((&sum;)f[z](eta),eta):
Theta(eta):=collect((&sum;)theta[z](eta),eta):
with(numapprox);
for k from 2 to 5 do W[k] := pade(diff(F(eta), eta), eta, [k, k]); Q[k] := pade(Theta(eta), eta, [k, k]); SOLL1[k] := expand(coeff(numer(W[k]), eta^k)) = 1; SOLL2[k] := expand(coeff(numer(Q[k]), eta^k)) = 0; SOL[k] := solve({SOLL1[k], SOLL2[k]}, {A, B}); print([k] = SOL[k]) end do;
Warning, computation interrupted

 

 

 

 

 

 

The presentation below is on undergrad Quantum Mechanics. Tackling this topic within a computer algebra worksheet in the way it's done below, however, is an exciting novelty and illustrates well the level of abstraction that is now possible using the Physics package.

 

Quantum Mechanics: Schrödinger vs Heisenberg picture

Pascal Szriftgiser1 and Edgardo S. Cheb-Terrab2 

(1) Laboratoire PhLAM, UMR CNRS 8523, Université Lille 1, F-59655, France

(2) Maplesoft

 

Within the Schrödinger picture of Quantum Mechanics, the time evolution of the state of a system, represented by a Ket "| psi(t) >", is determined by Schrödinger's equation:

I*`&hbar;`*(diff(Ket(psi, t), t)) = H*Ket(psi, t)

where H, the Hamiltonian, as well as the quantum operators O__S representing observable quantities, are all time-independent.

 

Within the Heisenberg picture, a Ket Ket(psi, 0) representing the state of the system does not evolve with time, but the operators O__H(t)representing observable quantities, and through them the Hamiltonian H, do.

 

Problem: Departing from Schrödinger's equation,

  

a) Show that the expected value of a physical observable in Schrödinger's and Heisenberg's representations is the same, i.e. that

Bra(psi, t)*O__S*Ket(psi, t) = Bra(psi, 0)*O__H(t)*Ket(psi, 0)

  

b) Show that the evolution equation of an observable O__H in Heisenberg's picture, equivalent to Schrödinger's equation,  is given by:

diff(O__H(t), t) = (-I*Physics:-Commutator(O__H(t), H))*(1/`&hbar;`)

where in the right-hand-side we see the commutator of O__H with the Hamiltonian of the system.

Solution: Let O__S and O__H respectively be operators representing one and the same observable quantity in Schrödinger's and Heisenberg's pictures, and H be the operator representing the Hamiltonian of a physical system. All of these operators are Hermitian. So we start by setting up the framework for this problem accordingly, including that the time t and Planck's constant are real. To automatically combine powers of the same base (happening frequently in what follows) we also set combinepowersofsamebase = true. The following input/output was obtained using the latest Physics update (Aug/31/2016) distributed on the Maplesoft R&D Physics webpage.

with(Physics):

Physics:-Setup(hermitianoperators = {H, O__H, O__S}, realobjects = {`&hbar;`, t}, combinepowersofsamebase = true, mathematicalnotation = true)

[combinepowersofsamebase = true, hermitianoperators = {H, O__H, O__S}, mathematicalnotation = true, realobjects = {`&hbar;`, t}]

(1)

Let's consider Schrödinger's equation

I*`&hbar;`*(diff(Ket(psi, t), t)) = H*Ket(psi, t)

I*`&hbar;`*(diff(Physics:-Ket(psi, t), t)) = Physics:-`*`(H, Physics:-Ket(psi, t))

(2)

Now, H is time-independent, so (2) can be formally solved: psi(t) is obtained from the solution psi(0) at time t = 0, as follows:

T := exp(-I*H*t/`&hbar;`)

exp(-I*t*H/`&hbar;`)

(3)

Ket(psi, t) = T*Ket(psi, 0)

Physics:-Ket(psi, t) = Physics:-`*`(exp(-I*t*H/`&hbar;`), Physics:-Ket(psi, 0))

(4)

To check that (4) is a solution of (2), substitute it in (2):

eval(I*`&hbar;`*(diff(Physics[Ket](psi, t), t)) = Physics[`*`](H, Physics[Ket](psi, t)), Physics[Ket](psi, t) = Physics[`*`](exp(-I*H*t/`&hbar;`), Physics[Ket](psi, 0)))

Physics:-`*`(H, exp(-I*t*H/`&hbar;`), Physics:-Ket(psi, 0)) = Physics:-`*`(H, exp(-I*t*H/`&hbar;`), Physics:-Ket(psi, 0))

(5)

Next, to relate the Schrödinger and Heisenberg representations of an Hermitian operator O representing an observable physical quantity, recall that the value expected for this quantity at time t during a measurement is given by the mean value of the corresponding operator (i.e., bracketing it with the state of the system Ket(psi, t)).

So let O__S be an observable in the Schrödinger picture: its mean value is obtained by bracketing the operator with equation (4):

Dagger(Ket(psi, t) = Physics[`*`](exp(-I*H*t/`&hbar;`), Ket(psi, 0)))*O__S*(Ket(psi, t) = Physics[`*`](exp(-I*H*t/`&hbar;`), Ket(psi, 0)))

Physics:-`*`(Physics:-Bra(psi, t), O__S, Physics:-Ket(psi, t)) = Physics:-`*`(Physics:-Bra(psi, 0), exp(I*t*H/`&hbar;`), O__S, exp(-I*t*H/`&hbar;`), Physics:-Ket(psi, 0))

(6)

The composed operator within the bracket on the right-hand-side is the operator O in Heisenberg's picture, O__H(t)

Dagger(T)*O__S*T = O__H(t)

Physics:-`*`(exp(I*t*H/`&hbar;`), O__S, exp(-I*t*H/`&hbar;`)) = O__H(t)

(7)

Analogously, inverting this equation,

(T*(Physics[`*`](exp(I*H*t/`&hbar;`), O__S, exp(-I*H*t/`&hbar;`)) = O__H(t)))*Dagger(T)

O__S = Physics:-`*`(exp(-I*t*H/`&hbar;`), O__H(t), exp(I*t*H/`&hbar;`))

(8)

As an aside to the problem, we note from these two equations, and since the operator T = exp((-I*H*t)*(1/`&hbar;`)) is unitary (because H is Hermitian), that the switch between Schrödinger's and Heisenberg's pictures is accomplished through a unitary transformation.

 

Inserting now this value of O__S from (8) in the right-hand-side of (6), we get the answer to item a)

lhs(Physics[`*`](Bra(psi, t), O__S, Ket(psi, t)) = Physics[`*`](Bra(psi, 0), exp(I*H*t/`&hbar;`), O__S, exp(-I*H*t/`&hbar;`), Ket(psi, 0))) = eval(rhs(Physics[`*`](Bra(psi, t), O__S, Ket(psi, t)) = Physics[`*`](Bra(psi, 0), exp(I*H*t/`&hbar;`), O__S, exp(-I*H*t/`&hbar;`), Ket(psi, 0))), O__S = Physics[`*`](exp(-I*H*t/`&hbar;`), O__H(t), exp(I*H*t/`&hbar;`)))

Physics:-`*`(Physics:-Bra(psi, t), O__S, Physics:-Ket(psi, t)) = Physics:-`*`(Physics:-Bra(psi, 0), O__H(t), Physics:-Ket(psi, 0))

(9)

where, on the left-hand-side, the Ket representing the state of the system is evolving with time (Schrödinger's picture), while on the the right-hand-side the Ket `&psi;__0`is constant and it is O__H(t), the operator representing an observable physical quantity, that evolves with time (Heisenberg picture). As expected, both pictures result in the same expected value for the physical quantity represented by O.

 

To complete item b), the derivation of the evolution equation for O__H(t), we take the time derivative of the equation (7):

diff((rhs = lhs)(Physics[`*`](exp(I*H*t/`&hbar;`), O__S, exp(-I*H*t/`&hbar;`)) = O__H(t)), t)

diff(O__H(t), t) = I*Physics:-`*`(H, exp(I*t*H/`&hbar;`), O__S, exp(-I*t*H/`&hbar;`))/`&hbar;`-I*Physics:-`*`(exp(I*t*H/`&hbar;`), O__S, H, exp(-I*t*H/`&hbar;`))/`&hbar;`

(10)

To rewrite this equation in terms of the commutator  Physics:-Commutator(O__S, H), it suffices to re-order the product  H  exp(I*H*t/`&hbar;`) placing the exponential first:

Library:-SortProducts(diff(O__H(t), t) = I*Physics[`*`](H, exp(I*H*t/`&hbar;`), O__S, exp(-I*H*t/`&hbar;`))/`&hbar;`-I*Physics[`*`](exp(I*H*t/`&hbar;`), O__S, H, exp(-I*H*t/`&hbar;`))/`&hbar;`, [exp(I*H*t/`&hbar;`), H], usecommutator)

diff(O__H(t), t) = I*Physics:-`*`(exp(I*t*H/`&hbar;`), H, O__S, exp(-I*t*H/`&hbar;`))/`&hbar;`-I*Physics:-`*`(exp(I*t*H/`&hbar;`), Physics:-`*`(H, O__S)+Physics:-Commutator(O__S, H), exp(-I*t*H/`&hbar;`))/`&hbar;`

(11)

Normal(diff(O__H(t), t) = I*Physics[`*`](exp(I*H*t/`&hbar;`), H, O__S, exp(-I*H*t/`&hbar;`))/`&hbar;`-I*Physics[`*`](exp(I*H*t/`&hbar;`), Physics[`*`](H, O__S)+Physics[Commutator](O__S, H), exp(-I*H*t/`&hbar;`))/`&hbar;`)

diff(O__H(t), t) = -I*Physics:-`*`(exp(I*t*H/`&hbar;`), Physics:-Commutator(O__S, H), exp(-I*t*H/`&hbar;`))/`&hbar;`

(12)

Finally, to express the right-hand-side in terms of  Physics:-Commutator(O__H(t), H) instead of Physics:-Commutator(O__S, H), we take the commutator of the equation (8) with the Hamiltonian

Commutator(O__S = Physics[`*`](exp(-I*H*t/`&hbar;`), O__H(t), exp(I*H*t/`&hbar;`)), H)

Physics:-Commutator(O__S, H) = Physics:-`*`(exp(-I*t*H/`&hbar;`), Physics:-Commutator(O__H(t), H), exp(I*t*H/`&hbar;`))

(13)

Combining these two expressions, we arrive at the expected result for b), the evolution equation of a given observable O__H in Heisenberg's picture

eval(diff(O__H(t), t) = -I*Physics[`*`](exp(I*H*t/`&hbar;`), Physics[Commutator](O__S, H), exp(-I*H*t/`&hbar;`))/`&hbar;`, Physics[Commutator](O__S, H) = Physics[`*`](exp(-I*H*t/`&hbar;`), Physics[Commutator](O__H(t), H), exp(I*H*t/`&hbar;`)))

diff(O__H(t), t) = -I*Physics:-Commutator(O__H(t), H)/`&hbar;`

(14)


Download:    Schrodinger_vs_Heisenberg_picture.mw     Schrodinger_vs_Heisenberg_picture.pdf

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft
Editor, Computer Physics Communications

Hello

It has been years since I last used maple so I apologize if my question makes no sense and my code is outdated (and wrong!).   

I need to write a function (proc) that uses a functional operator inside.  Something like

test:=proc()

local f,vars, func, aux, res;

f:=arg[1]; # a list

vars:=arg[2]: # a list

aux:=op(vars):

func:=aux -> f:  # a function from () to []

res:=func(op(func(aux))):

return(res):

end:

 

This is the basic idea of the proc.  If f:=[y, y*z-x, -15*x*y-x*z-x] and vars:=[x,y,z], the function of a function does not return as it supposes to.  Please tell me what I am doing wrong and how to improve and update the code.

 

many thanks

 

Ed

 

 

 

im just getting a generic recursive assignment plus first unused arg error

thats what the maple engine says im doing wrong ill get the number of recursives counted but i guess it just makes me the most angry because its like the same type of error for me every ******* time

First 1064 1065 1066 1067 1068 1069 1070 Last Page 1066 of 2228