Maple Questions and Posts

These are Posts and Questions associated with the product, Maple

Hello Everyone,

 

I have been working on a multi variable expression. I would like to have the intervals where the function is monotonically increasing. I am trying to study any available method for multivariable expressions.

I came across various papers and sites which are explicitly mentioned single variable equations. finding out the critical points and studying the sign of the first derivative. Same cannot be applied for the multi variable expression.

 https://www.math24.net/monotonic-functions/

above link explain for single variable functions. I would be grateful if someone could explain me a method or idea  which helps me out in solving for multivariable functions

 

Thanks a lot in advance

restart;
Digits := 25;

# Setup.
de := diff( x(t), t ) = a * y(t), diff( y(t), t ) = b * x(t);
ic := x(0) = 1, y(0) = 0;
sol := dsolve( { de, ic } ):

# Sample values for specific parameter values.
a0, b0 := 1.0, 0.25:
T := evalf( [ seq( i, i=1..5 ) ] ):
X := [ seq( eval['recurse']( x(t), [ op( sol ), a = a0, b = b0 ] ), t=T ) ]:
Y := [ seq( eval['recurse']( y(t), [ op( sol ), a = a0, b = b0 ] ), t=T ) ]:

# Numerical solution.
sol := dsolve( { de, ic }, 'numeric', 'range'=min(T)..max(T), 'abserr'=1e-15, 'maxfun'=0, 'parameters'=[a,b] ):

# Procedure to return values for specific time and parameter values.
u := proc( t, a, b )
	sol( 'parameters' = [ ':-a' = a, ':-b' = b ] ):
	try
		return eval( [ x( ':-t' ), y( ':-t' ) ], sol( t ) ):  
	catch:
		return 10000:
    end try:
end proc:

# Procedure to return objective function.
r := proc( a, b )
	local A, t, p, q, x, y:
	A := ListTools:-Flatten( [ seq( u( t, a, b ), t=T ) ] -~ zip( (x,y) -> [x,y], X, Y ) ):
	return foldl( (p,q) -> p + q^2, 0, op(A) ):
end proc:

# Find parameter values for bet fit.
Optimization:-Minimize( 'r'(a,b), a=-10..10, b=-10..10 );

I was provided the code above by Maple support, to fit a model to data using the Optimization package. I have tried to adapt this to a situation where one might only have the X variable data and so the model should only fit to that data.  I did this by deleting the , y( ':-t' ) in the try catch statement and then having the zip statement read as zip( (x) -> [x], X).

When I try to run that code, I get the error:

Error, (in Optimization:-NLPSolve) invalid input: zip uses a 3rd argument, b, which is missing

Anybody have an idea how to solve this?

 

Jo

Hi,

I try to define the action of projectors of two discrete basis onto a general state. This works as expected when I define the projector by myself. However, when using the "Projector" command, I get a not fully simplified result; see below. It seems like there is a confusion with dot/tensor product.  Can somoeone help?

Best,

Henrik


 

restart; with(Physics)

Setup(hilbertspaces = {{A, alpha}, {B, beta}}, quantumbasisdimension = {A = 1 .. N[a], B = 1 .. N[b]}, quantumdiscretebasis = {A, B, alpha, beta}, bracketrules = {%Bracket(Bra(A, i), Ket(Psi)) = Ket(beta, i), %Bracket(Bra(A, i), Ket(alpha, j)) = C[i, j], %Bracket(Bra(B, i), Ket(Psi)) = Ket(alpha, i), %Bracket(Bra(B, j), Ket(beta, i)) = C[i, j]})

[bracketrules = {%Bracket(%Bra(A, i), %Ket(Psi)) = Physics:-Ket(beta, i), %Bracket(%Bra(A, i), %Ket(alpha, j)) = C[i, j], %Bracket(%Bra(B, i), %Ket(Psi)) = Physics:-Ket(alpha, i), %Bracket(%Bra(B, j), %Ket(beta, i)) = C[i, j]}, disjointedspaces = {{A, alpha}, {B, beta}}, quantumbasisdimension = {A = 1 .. N[a], B = 1 .. N[b]}, quantumdiscretebasis = {A, B, alpha, beta}]

(1)

``

proj := Sum(Sum(Ket(A, i).Bra(A, i).Ket(B, j).Bra(B, j), i = 1 .. N[a]), j = 1 .. N[b])

Sum(Sum(Physics:-`*`(Physics:-Ket(A, i), Physics:-Ket(B, j), Physics:-Bra(A, i), Physics:-Bra(B, j)), i = 1 .. N[a]), j = 1 .. N[b])

(2)

proj2 := Projector(Ket(A, i)).Projector(Ket(B, i))

Physics:-`*`(Sum(Physics:-`*`(Physics:-Ket(A, i), Physics:-Bra(A, i)), i = 1 .. N[a]), Sum(Physics:-`*`(Physics:-Ket(B, i), Physics:-Bra(B, i)), i = 1 .. N[b]))

(3)

proj.Ket(Psi)

Sum(Sum(C[i, j]*Physics:-`*`(Physics:-Ket(A, i), Physics:-Ket(B, j)), i = 1 .. N[a]), j = 1 .. N[b])

(4)

NULL

proj2.Ket(Psi)

Sum(Sum(Physics:-`*`(Physics:-Ket(A, i__1), Physics:-Bra(A, i__1), Physics:-Ket(alpha, i), Physics:-Ket(B, i)), i = 1 .. N[b]), i__1 = 1 .. N[a])

(5)

proj-proj2

Sum(Sum(Physics:-`*`(Physics:-Ket(A, i), Physics:-Ket(B, j), Physics:-Bra(A, i), Physics:-Bra(B, j)), i = 1 .. N[a]), j = 1 .. N[b])-Physics:-`*`(Sum(Physics:-`*`(Physics:-Ket(A, i), Physics:-Bra(A, i)), i = 1 .. N[a]), Sum(Physics:-`*`(Physics:-Ket(B, i), Physics:-Bra(B, i)), i = 1 .. N[b]))

(6)

``


 

Download projector_2d_space.mw

 

Two lines that look the same, produce different results. The first lines gives an error message, but the next line that looks the same, does not.

copying and pasting both lines in Notepad reveals the difference:

Determinant*(R1 . B+R2 . B+R3 . B+R4 . A)

Determinant(R1 . B+R2 . B+R3 . B+R4 . A)

It seems that there is a hidden character (the asterisk) in the first line that produces the error.

In the worksheet itself you cannot see the asterisk, but using the arrow keys you can notice that there is another character.

It's hard to debug your code if there are hidden characters.

``

restart; with(LinearAlgebra)

kernelopts(version)*interface(version)

`Maple 2018.2, X86 64 WINDOWS, Nov 16 2018, Build ID 1362973`*`Standard Worksheet Interface, Maple 2018.2, Windows 10, November 16 2018 Build ID 1362973`

(1)

A := Matrix(4, 4, symbol = a, shape = symmetric)

B := Matrix(4, 4, symbol = b, shape = symmetric)

R1 := Matrix(4, 4); R1[1, 1] := 1; R2 := Matrix(4, 4); R2[2, 2] := 1; R3 := Matrix(4, 4); R3[3, 3] := 1; R4 := Matrix(4, 4); R4[4, 4] := 1

Determinant*(R1.B+R2.B+R3.B+R4.A)

Error, (in LinearAlgebra:-Multiply) invalid arguments

 

Determinant(R1.B+R2.B+R3.B+R4.A)

-a[1, 4]*b[1, 2]*b[2, 3]*b[3, 4]+a[1, 4]*b[1, 2]*b[2, 4]*b[3, 3]+a[1, 4]*b[1, 3]*b[2, 2]*b[3, 4]-a[1, 4]*b[1, 3]*b[2, 3]*b[2, 4]-a[1, 4]*b[1, 4]*b[2, 2]*b[3, 3]+a[1, 4]*b[1, 4]*b[2, 3]^2+a[2, 4]*b[1, 1]*b[2, 3]*b[3, 4]-a[2, 4]*b[1, 1]*b[2, 4]*b[3, 3]-a[2, 4]*b[1, 2]*b[1, 3]*b[3, 4]+a[2, 4]*b[1, 2]*b[1, 4]*b[3, 3]+a[2, 4]*b[1, 3]^2*b[2, 4]-a[2, 4]*b[1, 3]*b[1, 4]*b[2, 3]-a[3, 4]*b[1, 1]*b[2, 2]*b[3, 4]+a[3, 4]*b[1, 1]*b[2, 3]*b[2, 4]+a[3, 4]*b[1, 2]^2*b[3, 4]-a[3, 4]*b[1, 2]*b[1, 3]*b[2, 4]-a[3, 4]*b[1, 2]*b[1, 4]*b[2, 3]+a[3, 4]*b[1, 3]*b[1, 4]*b[2, 2]+a[4, 4]*b[1, 1]*b[2, 2]*b[3, 3]-a[4, 4]*b[1, 1]*b[2, 3]^2-a[4, 4]*b[1, 2]^2*b[3, 3]+2*a[4, 4]*b[1, 2]*b[1, 3]*b[2, 3]-a[4, 4]*b[1, 3]^2*b[2, 2]

(2)

``


 

Download weird.mw

i want to generate grid for a C_D nozzle but i dont know ho to plot it. please help me how to plot.

restart;
alpha := 0;
beta := 2;
Imax := 11;
Jmax := 11;
L := 10;
`Δζ` := L/(Imax-1);

`Δx` := `Δζ`;
`Δη` := 1/(Jmax-1);

printlevel := 2;
for i to Imax do for j to Jmax do x[i] := `Δζ`*(i-1); eta[j] := `Δη`*(j-1); z := (eta[j]-alpha)*ln((beta+1)/(beta-1))/(1-alpha); H[i] := 3+2*tanh(x[i]-6); H1[i] := 0; H2[i] := -H[i]; y[i, j] := -H[i]*(2*beta/(exp(z)+1)-beta-2*alpha)/(2*alpha+1); Y[i, j] := (H1[i]+(-H1[i]*x[i]+H2[i])/L)*eta[j] end do end do;

 

 

If I have an expression like this

f:=ln((1-x)^2*(x+1)^2/((-I*x-I+sqrt(-x^2+1))^2*(I*x+I+sqrt(-x^2+1))^2))

maple has trouble to simplify the argument.

In particular is it possible to apply expand() only to the denominator?

This is meant in general, so if I have many terms with expressions like this (possibly of products with other functions in each term), I want this simplification to be done termwise for the arguments of the functions.

Expanding the fraction doesn't work as in frontend(expand, [f]).

Hi,

I am looking to test ANOVA ( Two Way).Maple does not directly gives this possibility.I found a procedure from Mr Tannis but i can t run it? Some ideas?

ThanksANOVA2.mw

This is not a problem per se, but more to understand the background.

restart;

f := polylog(2, -x);

int(f/(x+1), x);

convert(f, dilog);

int(%/(x+1), x)

 

The integration of the polylog maple is not capable of doing, but after converting to dilog it finds an anti derivative.

That leads to the question, why is dilog as a separate to polylog(2,*) implemented anyway? Why couldn't it all be done with the more general polylog function?

 

I'm also wondering why maple has difficulties to integrate

int(dilog(x+1)/(x+a),x)

for general a.

How would I go about getting true or false returned on these propositions?
I have tried just about every eval and various syntax methods, but nothing has worked so far.

I know most can easilly be done by hand/thinking, but I'm sure Maple should have a way to do this as well.

∀n∈Z:2n>n+2   ,   ∃n∈Z:2|(3n+1)    ,   ∃k∈Z:∀n∈Z:n=kn   ,   ∃k∈Z:∀n∈Z:2|(n+k)   ,   ∀n∈Z:∀k∈Z:(n>k∨k≥n)


Coherent States in Quantum Mechanics

 

Pascal Szriftgiser1 and Edgardo S. Cheb-Terrab2 

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

(2) Maplesoft

 

  

Coherent states are among the most relevant representations for the state of a quantum system. These states, that form an overcomplete basis, minimize the quantum uncertainty between position x and momentum p (they satisfy the Heisenberg uncertainty principle with equality and their expectation values satisfy the classical equations of motion). Coherent states are widely used in quantum optics and quantum mechanics in general; they also mathematically characterize the concept of Planck cells. Part of this development is present in Maple 2018.2.1. To reproduce what you see below, however, you need a more recent version, as the one distributed within the Maplesoft Physics Updates (version 276 or higher). A worksheet with this contents is linked at the end of this post.

Definition and the basics

 

with(Physics)

 

Set a quantum operator A and corresponding annihilation / creation operators

Setup(quantumoperators = A)

[quantumoperators = {A}]

(1.1)

am := Annihilation(A)

`#msup(mi("a"),mo("&uminus0;"))`

(1.2)

ap := Creation(A)

`#msup(mi("a"),mo("+"))`

(1.3)

In what follows, on the left-hand sides the product operator used is `*`, which properly represents, but does not perform the attachment of Bras Kets and operators. On the right-hand sides the product operator is `.`, that performs the attachments. Since the introduction of Physics in the Maple system, we have that

am*Ket(A, n) = am.Ket(A, n)

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(A, n)) = n^(1/2)*Physics:-Ket(A, n-1)

(1.4)

(%Bracket = Bracket)(Bra(A, n), Ket(A, n))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(A, n)) = 1

(1.5)

(%Bracket = Bracket)(Bra(A, n), Ket(A, m))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(A, m)) = Physics:-KroneckerDelta[m, n]

(1.6)

New development during 2018: coherent states, the eigenstates of the annihilation operator `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`, with all of their properties, are now understood as such by the system

am*Ket(am, alpha) = am.Ket(am, alpha)

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = alpha*Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)

(1.7)

Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) is an eigenket of `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))` but not of  `#msup(mi("a",mathcolor = "olive"),mo("+",mathcolor = "olive"))`

ap.Ket(am, alpha)

Physics:-`.`(`#msup(mi("a"),mo("+"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(1.8)

The norm of these states is equal to 1

(%Bracket = Bracket)(Bra(am, alpha), Ket(am, alpha))

%Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = 1

(1.9)

These states, however, are not orthonormal as the occupation number states Ket(A, n) are, and since `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))` is not Hermitian, its eigenvalues are not real but complex numbers. Instead of (1.6) , we now have

(%Bracket = Bracket)(Bra(am, alpha), Ket(am, beta))

%Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, beta)) = exp(-(1/2)*abs(alpha)^2-(1/2)*abs(beta)^2+conjugate(alpha)*beta)

(1.10)

At alpha = beta,

simplify(eval(%Bracket(Physics[Bra](`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, beta)) = exp(-(1/2)*abs(alpha)^2-(1/2)*abs(beta)^2+conjugate(alpha)*beta), alpha = beta))

1 = 1

(1.11)

Their scalar product with the occupation number states Ket(A, m), using the inert %Bracket on the left-hand side and the active Bracket on the other side:

(%Bracket = Bracket)(Bra(A, n), Ket(am, alpha))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)

(1.12)

The expansion of coherent states into occupation number states, first representing the product operation using `*`, then performing the attachments replacing `*` by `.`

Projector(Ket(A, n), dimension = infinity)

Sum(Physics:-`*`(Physics:-Ket(A, n), Physics:-Bra(A, n)), n = 0 .. infinity)

(1.13)

Ket(am, alpha) = (Sum(Physics[`*`](Physics[Ket](A, n), Physics[Bra](A, n)), n = 0 .. infinity))*Ket(am, alpha)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics:-`*`(Sum(Physics:-`*`(Physics:-Ket(A, n), Physics:-Bra(A, n)), n = 0 .. infinity), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(1.14)

eval(Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Physics[Ket](A, n), Physics[Bra](A, n)), n = 0 .. infinity), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha)), `*` = `.`)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

(1.15)

Hide now the ket label. When in doubt, input show to see the Kets with their labels explicitly shown

Setup(hide = true)

`* Partial match of  '`*hide*`' against keyword '`*hideketlabel*`' `

 

_______________________________________________________

 

[hideketlabel = true]

(1.16)

Define eigenkets of the annihilation operator, with two different eigenvalues for experimentation

`K__α` := Ket(am, alpha)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)

(1.17)

`K__β` := Ket(am, beta)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, beta)

(1.18)

Because the properties of coherent states are now known to the system, the following computations proceed automatically. The left-hand sides use the `*`, while the right-hand sides use the `.`

(`*` = `.`)(Dagger(`K__α`), ap, am, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), `#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = abs(alpha)^2

(1.19)

(`*` = `.`)(Dagger(`K__α`), ap+am, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), `#msup(mi("a"),mo("+"))`+`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = conjugate(alpha)+alpha

(1.20)

(`*` = `.`)(Dagger(`K__α`), ap-am, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), `#msup(mi("a"),mo("+"))`-`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = conjugate(alpha)-alpha

(1.21)

(`*` = `.`)(Dagger(`K__α`), (ap+am)^2, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-`^`(`#msup(mi("a"),mo("+"))`+`#msup(mi("a"),mo("&uminus0;"))`, 2), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = conjugate(alpha)^2+2*abs(alpha)^2+1+alpha^2

(1.22)

Properties of Coherent states

 

The mean value of the occupation number N

 

 

The occupation number operator N is given by

N := ap.am

Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)

(2.1.1)

N*` is Hermitian`

%Dagger(N) = N

%Dagger(Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)) = Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)

(2.1.2)

value(%Dagger(Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)) = Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`))

Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`) = Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)

(2.1.3)

N is diagonal in the Ket(A, n) basis of the Fock (occupation number) space

(`*` = `.`)(Bra(A, n), N, Ket(A, p))

Physics:-`*`(Physics:-Bra(A, n), `#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(A, p)) = p*Physics:-KroneckerDelta[n, p]

(2.1.4)
• 

The mean value of N in a coherent state `≡`(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Ket(alpha))

Bracket(%N)[alpha] = %Bracket(Bra(am, alpha), N, Ket(am, alpha))

Physics:-Bracket(%N)[alpha] = %Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(2.1.5)

value(Physics[Bracket](%N)[alpha] = %Bracket(Physics[Bra](`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha)))

Physics:-Bracket(%N)[alpha] = abs(alpha)^2

(2.1.6)

The mean value of N^2

Bracket(%N^2)[alpha] = %Bracket(Bra(am, alpha), N^2, Ket(am, alpha))

Physics:-Bracket(%N^2)[alpha] = %Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-`^`(Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(2.1.7)

value(Physics[Bracket](%N^2)[alpha] = %Bracket(Physics[Bra](`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics[`^`](Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha)))

Physics:-Bracket(%N^2)[alpha] = abs(alpha)^4+abs(alpha)^2

(2.1.8)

The standard deviation `ΔN` = sqrt(-Bracket(%N)[alpha]^2+Bracket(%N^2)[alpha]) for a state Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)

((Physics[Bracket](%N^2)[alpha] = abs(alpha)^4+abs(alpha)^2)-(Physics[Bracket](%N)[alpha] = abs(alpha)^2)^2)^(1/2)

(-Physics:-Bracket(%N)[alpha]^2+Physics:-Bracket(%N^2)[alpha])^(1/2) = abs(alpha)

(2.1.9)

In conclusion, a coherent state "| alpha >" has a finite spreading `ΔN` = abs(alpha).  Coherent states are good approximations for the states of a laser, where the laser intensity I  is proportional to the mean value of the photon number, I f Bracket(%N)[alpha] = abs(alpha)^2, and so the intensity fluctuation, `∝`(sqrt(I), abs(alpha)).

• 

The mean value of the occupation number N in an occupation number state `≡`(Ket(A, n), Ket(n))

Bracket(%N)[n] = %Bracket(Bra(A, n), N, Ket(A, n))

Physics:-Bracket(%N)[n] = %Bracket(Physics:-Bra(A, n), Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Physics:-Ket(A, n))

(2.1.10)

value(Physics[Bracket](%N)[n] = %Bracket(Bra(A, n), Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Ket(A, n)))

Physics:-Bracket(%N)[n] = n

(2.1.11)

The mean value of the occupation number N in a state Ket(A, n) is thus n itself, as expected since Ket(A, n)represents a (Fock space) state of n (quase-) particles. Accordingly,

Bracket(%N^2)[n] = %Bracket(Bra(A, n), N^2, Ket(A, n))

Physics:-Bracket(%N^2)[n] = %Bracket(Physics:-Bra(A, n), Physics:-`^`(Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Physics:-Ket(A, n))

(2.1.12)

value(Physics[Bracket](%N^2)[n] = %Bracket(Bra(A, n), Physics[`^`](Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Ket(A, n)))

Physics:-Bracket(%N^2)[n] = n^2

(2.1.13)

The standard deviation `ΔN` = sqrt(-Bracket(%N)[n]^2+Bracket(%N^2)[n]) for a state Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha), is thus

((Physics[Bracket](%N^2)[n] = n^2)-(Physics[Bracket](%N)[n] = n)^2)^(1/2)

(-Physics:-Bracket(%N)[n]^2+Physics:-Bracket(%N^2)[n])^(1/2) = 0

(2.1.14)

That is, in a Fock state, `ΔN` = 0,  there is no intensity fluctuation.

"a^(-)| alpha > = alpha| alpha >"

 

 

The specific properties of coherent states implemented can be derived explicitly departing from the projection of "Ket(a^(-),alpha"into the Ket(A, m)basis of occupation number states and the definition of `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))` as the operator that annihilates the vacuum `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`Ket(A, n) = 0

Ket(am, alpha) = (Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity))*Ket(am, alpha)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics:-`*`(Sum(Physics:-`*`(Physics:-Ket(A, n), Physics:-Bra(A, n)), n = 0 .. infinity), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(2.2.1)

eval(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)), `*` = `.`)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

(2.2.2)

To derive `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`*Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = alpha*Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) from the formula above, start multiplying by `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`

am*(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

(2.2.3)

In view of `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`*Ket(A, 0) = 0, discard the first term of the sum

subs(0 = 1, Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)))

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 1 .. infinity))

(2.2.4)

Change variables n = k+1; in the result rename proc (k) options operator, arrow; n end proc

subs(k = n, PDEtools:-dchange(n = k+1, Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 1 .. infinity)), `@`(combine, simplify)))

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(A, n+1))*alpha^(n+1)/(factorial(n)^(1/2)*(n+1)^(1/2)), n = 0 .. infinity)

(2.2.5)

Activate the product `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`*Ket(A, n+1) by replacing, in the right-hand side, the product operator `*` by `.`

lhs(Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(A, n+1))*alpha^(n+1)/(factorial(n)^(1/2)*(n+1)^(1/2)), n = 0 .. infinity)) = eval(rhs(Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(A, n+1))*alpha^(n+1)/(factorial(n)^(1/2)*(n+1)^(1/2)), n = 0 .. infinity)), `*` = `.`)

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics:-Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity)

(2.2.6)

By inspection the right-hand side of (2.2.6) is equal to alpha times the right-hand side of (2.2.2)

alpha*(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))-(Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity))

alpha*Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)-Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = alpha*(Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))-(Sum(exp(-(1/2)*abs(alpha)^2)*Physics:-Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity))

(2.2.7)

combine(alpha*Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)-Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = alpha*(Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))-(Sum(exp(-(1/2)*abs(alpha)^2)*Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity)))

alpha*Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)-Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = 0

(2.2.8)
• 

Overview of the coherent states distribution

 

Consider the projection of Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) over an occupation number state Ket(A, n)

%Bracket(Bra(A, n), lhs(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)))) = Bracket(Bra(A, n), rhs(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)

(2.2.9)

An overview of the distribution of coherent states Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) for a sample of values of n and alpha is thus as follows

plot3d(rhs(%Bracket(Bra(A, n), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)), n = 0 .. 25, alpha = 0 .. 10, axes = boxed, caption = lhs(%Bracket(Bra(A, n), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)))

 

The distribution can be explored for ranges of values of n and alpha using Explore

NA := Typesetting:-Typeset(Bracket(Bra(A, n), Ket(am, alpha)))

Explore(plot(rhs(%Bracket(Bra(A, n), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)), n = 0 .. 200, view = 0 .. .6, labels = [n, NA]), parameters = [alpha = 0 .. 10], initialvalues = [alpha = 5])

"a^(+)| alpha >= (∂)/(∂alpha) | alpha >+(alpha)/2 | alpha >"

   

exp(-(1/2)*abs(alpha)^2)*exp(alpha*`#msup(mi("a",mathcolor = "olive"),mo("+",mathcolor = "olive"))`)"| 0 >" = "| alpha >"

   

 exp(alpha*`#msup(mi("a",mathcolor = "olive"),mo("+",mathcolor = "olive"))`-conjugate(alpha)*a)" | 0 >" = "| alpha >"

   

`<|>`(beta, alpha) = exp(conjugate(beta)*alpha-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2)

 

NULL

The identity in the title can be derived departing again from the the projection of a coherent stateKet(`#msup(mi("a"),mo("&uminus0;"))`, alpha)into the Ket(A, m)basis of occupation number states

Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

(2.6.1)

Dagger(subs({alpha = beta, n = k}, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)))

Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta) = Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Physics:-Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity)

(2.6.2)

Taking the `*` product of these two expressions

(Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta) = Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity))*(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics:-`*`(Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Physics:-Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity), Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

(2.6.3)

Perform the attachment of Bras and Kets on the right-hand side by replacing `*` by `.`, evaluating the sum and simplifying the result

lhs(Physics[`*`](Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity), Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))) = simplify(value(eval(rhs(Physics[`*`](Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity), Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))), `*` = `.`)))

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2+alpha*conjugate(beta))

(2.6.4)
• 

Overview of the real and imaginary part of `<|>`(beta, alpha)

 

In most cases, alpha and beta are complex valued numbers. Below, the plots assume that alpha and beta are both real. To take into account the general case, the possibility to tune a phase difference theta between alpha and beta is explicitly added, so that (2.6.4) becomes

 

%Bracket(Bra(am, beta), Ket(am, alpha)) = subs(conjugate(beta) = conjugate(beta)*exp(I*theta), rhs(Physics[`*`](Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(conjugate(beta)*alpha-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2)))

%Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2+alpha*conjugate(beta)*exp(I*theta))

(2.6.5)

Explore(plot3d(Re(rhs(%Bracket(Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2+alpha*conjugate(beta)*exp(I*theta)))), alpha = -10 .. 10, beta = -10 .. 10, view = -1 .. 1, orientation = [-12, 74, 3], axes = boxed), parameters = [theta = 0 .. 2*Pi], initialvalues = [theta = (1/10)*Pi])

 

 

Download Coherent_States_in_Quantum_Mechanics.mw

 

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

 

Using Maple 2018.2.1, I'm receiving a lost kernel message when importing the attached data file with ImportMatrix. I traced the issue to a "*" symbol at the end of the file but would have expected this to cause an error message (if any error at all) instead of the connection to the kernel to be lost. Is this a bug or am I misunderstanding the usage of ImportMatrix?

test.mw

test2.txt


i want someone hlep me in this worksheet the diff eq of complex i want to sovle it with any numeric method 
 

restart

with(Physics):

with(IntegrationTools):

v := 1;

1

 

-500

 

.1

 

.5

 

.5

(1)

``

M[1] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)

Int(-(2*I)*exp(-(.5*I)*tt)/((0.1e-1+tt^2)^(1/2)*exp((0.1e-1+tt^2)^(1/2)))+(2*I)*exp((.5*I)*tt)/((0.1e-1+tt^2)^(1/2)*exp((0.1e-1+tt^2)^(1/2))), tt = -500 .. z)

(2)

M[2] := Int(Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

M[3] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

M[4] := Int(-Physics:-`*`(Physics:-`*`(2, exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(2, exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

M := Physics:-`*`(z^2, M[1])+Physics:-`*`(z, M[2])+Physics:-`*`(z, M[3])+M[4]:

Mc[1] := Physics:-`*`(z^2, Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Mc[2] := Physics:-`*`(z, Int(Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Mc[3] := Physics:-`*`(z, Int(-Physics:-`*`(Physics:-`*`(2, exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(2, exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Mc[4] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

Mc := Mc[1]+Mc[2]+Mc[3]+Mc[4]:

N[1] := Int(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/exp(sqrt(b^2+tt^2))), tt = -500 .. z):

N[2] := Physics:-`*`(z, Int(-Physics:-`*`(Physics:-`*`(2, exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(2, exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

N := N[1]+N[2]:

Nc[1] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(2., tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2., tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(2., I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/exp(sqrt(b^2+tt^2))), tt = -500 .. z):

Nc[2] := Physics:-`*`(z, Int(Physics:-`*`(Physics:-`*`(2., exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(2., exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Nc := Nc[1]+Nc[2]:

V := Physics:-`*`(Physics:-`*`(1/Physics:-`*`(4, Pi^2), 1/sqrt(b^2+z^2)), Physics:-`*`(exp(-Physics:-`*`(2, sqrt(b^2+z^2))), Physics:-`*`(2, sqrt(b^2+z^2))+2)-2):

Vc := Physics:-`*`(Physics:-`*`(Physics:-`*`(-1, 1/Physics:-`*`(4, Pi^2)), 1/sqrt(b^2+z^2)), Physics:-`*`(exp(-Physics:-`*`(2, sqrt(b^2+z^2))), Physics:-`*`(2, sqrt(b^2+z^2))+2)-2):

``

H := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2)+(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)+I*((-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int((-1)*2.*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2.*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*I*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(2.*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

H(500)

-6.287499768+0.1713975e-19*I

(3)

NULL

L := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*((-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(2*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))-2*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(2*I)*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(-2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)+I*(-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2)-(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

``

G := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(I*(-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2)+(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*((-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int((-1)*2.*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2.*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*I*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(2.*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

``

K := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(I*((-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(2*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))-2*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(2*I)*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(-2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2)-(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

NULL

NULL

sys := {diff(X(z), z) = Physics:-`*`(H(z), Y(z))+Physics:-`*`(L(z), X(z)), diff(Y(z), z) = Physics:-`*`(G(z), Y(z))+Physics:-`*`(K(z), X(z))}

{diff(X(z), z) = H(z)*Y(z)+L(z)*X(z), diff(Y(z), z) = G(z)*Y(z)+K(z)*X(z)}

(4)

IC_1 := {X(-500) = 0, Y(-500) = 1}

{X(-500) = 0, Y(-500) = 1}

(5)

dsol3 := dsolve(`union`(sys, IC_1), numeric, method = dverk78, output = procedurelist, known = [H, L, G, K])

proc (x_dverk78) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if 1 < nargs then error "invalid input: too many arguments" end if; _EnvDSNumericSaveDigits := Digits; Digits := 15; if _EnvInFsolve = true then _xout := evalf[_EnvDSNumericSaveDigits](x_dverk78) else _xout := evalf(x_dverk78) end if; _dat := Array(1..4, {(1) = proc (_xin) local _xout, _fcn, _i, _octl, _ctl, _y0, _yini, _ycur, _reinit, _pars, _n, _ysav, _ini, _par; option `Copyright (c) 1993 by the University of Waterloo. All rights reserved.`; Digits := max(15, Digits); _xout := _xin; _octl := array( 1 .. 32, [( 1 ) = (3), ( 2 ) = (1), ( 3 ) = (0), ( 4 ) = (0), ( 5 ) = (0), ( 6 ) = (0), ( 7 ) = (0), ( 9 ) = (1), ( 8 ) = (0), ( 11 ) = (-1), ( 10 ) = (-1), ( 13 ) = (-1), ( 12 ) = (-1), ( 15 ) = (-1), ( 14 ) = (-1), ( 18 ) = (-1), ( 19 ) = (-1), ( 16 ) = (-1), ( 17 ) = (-500.), ( 22 ) = (-1), ( 23 ) = (-1), ( 20 ) = (-500.), ( 21 ) = (-1), ( 27 ) = (-499.), ( 26 ) = (2), ( 25 ) = (-500.), ( 24 ) = (0), ( 31 ) = (-500.), ( 30 ) = (1), ( 29 ) = (2), ( 28 ) = (0.1e-7), ( 32 ) = (0)  ] ); _yini := Array(0..2, {(1) = -500., (2) = 0.}); _y0 := Array(0..2, {(1) = -500., (2) = 0.}); _ycur := array( 1 .. 2, [ ] ); _ctl := array( 1 .. 32, [( 1 ) = (3), ( 2 ) = (1), ( 3 ) = (0), ( 4 ) = (0), ( 5 ) = (0), ( 6 ) = (0), ( 7 ) = (0), ( 9 ) = (1), ( 8 ) = (0), ( 11 ) = (-1), ( 10 ) = (-1), ( 13 ) = (-1), ( 12 ) = (-1), ( 15 ) = (-1), ( 14 ) = (-1), ( 18 ) = (-1), ( 19 ) = (-1), ( 16 ) = (-1), ( 17 ) = (-500.), ( 22 ) = (-1), ( 23 ) = (-1), ( 20 ) = (-500.), ( 21 ) = (-1), ( 27 ) = (-499.), ( 26 ) = (2), ( 25 ) = (-500.), ( 24 ) = (0), ( 31 ) = (-500.), ( 30 ) = (1), ( 29 ) = (2), ( 28 ) = (0.1e-7), ( 32 ) = (0)  ] ); _fcn := proc (N, X, Y, YP) option `[Y[1] = X(z), Y[2] = Y(z)]`; YP[1] := H(X)*Y[2]+L(X)*Y[1]; YP[2] := G(X)*Y[2]+K(X)*Y[1]; 0 end proc; _pars := []; _n := 2; _ysav := Array(1..2, {(1) = 0., (2) = 1.}); if not type(_xout, 'numeric') then if member(_xout, ["start", "left", "right"]) then return _y0[0] elif _xout = "method" then return "dverk78" elif _xout = "numfun" then return round(_ctl[24]) elif _xout = "initial" then return [seq(_yini[_i], _i = 0 .. _n)] elif _xout = "parameters" then return [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] elif _xout = "initial_and_parameters" then return [seq(_yini[_i], _i = 0 .. _n)], [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] elif _xout = "last" then if _ctl[17]-_y0[0] = 0. then error "no information is available on last computed point" else _xout := _ctl[17] end if elif _xout = "enginedata" then return eval(_octl, 1) elif _xout = "function" then return eval(_fcn, 1) elif type(_xin, `=`) and type(rhs(_xin), 'list') and member(lhs(_xin), {"initial", "parameters", "initial_and_parameters"}) then _ini, _par := [], []; if lhs(_xin) = "initial" then _ini := rhs(_xin) elif lhs(_xin) = "parameters" then _par := rhs(_xin) elif select(type, rhs(_xin), `=`) <> [] then _par, _ini := selectremove(type, rhs(_xin), `=`) elif nops(rhs(_xin)) < nops(_pars)+1 then error "insufficient data for specification of initial and parameters" else _par := rhs(_xin)[-nops(_pars) .. -1]; _ini := rhs(_xin)[1 .. -nops(_pars)-1] end if; _xout := lhs(_xout); if _par <> [] then `dsolve/numeric/process_parameters`(_n, _pars, _par, _yini) end if; if _ini <> [] then `dsolve/numeric/process_initial`(_n, _ini, _yini, _pars) end if; if _pars <> [] then _par := {seq(rhs(_pars[_i]) = _yini[_n+_i], _i = 1 .. nops(_par))}; for _i from 0 to _n do _y0[_i] := subs(_par, _yini[_i]) end do; for _i from _n+1 to _n+nops(_pars) do _y0[_i] := _yini[_i] end do else for _i from 0 to _n do _y0[_i] := _yini[_i] end do end if; _octl[25] := _y0[0]; _octl[20] := _y0[0]; _octl[17] := _y0[0]; _octl[31] := _y0[0]; for _i to op(2, op(2, op(_octl))) do _ctl[_i] := _octl[_i] end do; for _i to _n+nops(_pars) do _ysav[_i] := _y0[_i] end do; if _xout = "initial" then return [seq(_yini[_i], _i = 0 .. _n)] elif _xout = "parameters" then return [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] else return [seq(_yini[_i], _i = 0 .. _n)], [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] end if else return "procname" end if end if; if _y0[0]-_xout = 0. then return [seq(_y0[_i], _i = 0 .. _n)] elif _octl[31]-_y0[0] = 0. then _octl[31] := _y0[0]-sign(_xout-_y0[0]) end if; _reinit := false; if _xin <> "last" then if 0 < 0 and `dsolve/numeric/checkglobals`(0, table( [ ] ), _pars, _n, _yini) then _reinit := true; if _pars <> [] then _par := {seq(rhs(_pars[_i]) = _yini[_n+_i], _i = 1 .. nops(_par))}; for _i from 0 to _n do _y0[_i] := subs(_par, _yini[_i]) end do; for _i from _n+1 to _n+nops(_pars) do _y0[_i] := _yini[_i] end do else for _i from 0 to _n do _y0[_i] := _yini[_i] end do end if end if; if _pars <> [] and select(type, {seq(_yini[_n+_i], _i = 1 .. nops(_pars))}, 'undefined') <> {} then error "parameters must be initialized before solution can be computed" end if end if; if _reinit or _ctl[17]-_xout <> 0. then if _reinit or 0 < _ctl[18] and _xout < _ctl[31] or _ctl[18] < 0 and _ctl[31] < _xout then for _i to op(2, op(2, op(_octl))) do _ctl[_i] := _octl[_i] end do; for _i to _n+nops(_pars) do _ysav[_i] := _y0[_i] end do else _ctl[29] := 2 end if; _ctl[9] := 2; _ctl[27] := _xout; if Digits <= trunc(evalhf(Digits)) then try evalhf(`dsolve/numeric/dverk78_engine`(_fcn, var(_ysav), var(_ycur), `dsolve/numeric/dverk78_aa`, `dsolve/numeric/dverk78_cc`, `dsolve/numeric/dverk78_dd`, var(_ctl), var(array( 1 .. 2, [ ] )), var(array( 1 .. 2, [ ] )), var(array( 1 .. 2, 1 .. 23, [ ] )))) catch: if searchtext('evalhf', lastexception[2]) <> 0 or searchtext('real', lastexception[2]) <> 0 or searchtext('hardware', lastexception[2]) <> 0 then `dsolve/numeric/dverk78_engine`(_fcn, _ysav, _ycur, `dsolve/numeric/dverk78_aa`, `dsolve/numeric/dverk78_cc`, `dsolve/numeric/dverk78_dd`, _ctl, array( 1 .. 2, [ ] ), array( 1 .. 2, [ ] ), array( 1 .. 2, 1 .. 23, [ ] )) else error  end if end try else `dsolve/numeric/dverk78_engine`(_fcn, _ysav, _ycur, `dsolve/numeric/dverk78_aa`, `dsolve/numeric/dverk78_cc`, `dsolve/numeric/dverk78_dd`, _ctl, array( 1 .. 2, [ ] ), array( 1 .. 2, [ ] ), array( 1 .. 2, 1 .. 23, [ ] )) end if; if _ctl[29]-3 <> 0 then Rounding := `if`(_y0[0] < _xout, -infinity, infinity); if _ctl[29]+1 = 0 then error "cannot evaluate the solution past %1, maxfun limit exceeded (see <a href='http://www.maplesoft.com/support/help/search.aspx?term=dsolve,maxfun' target='_new'>?dsolve,maxfun</a> for details)", evalf[8](_ctl[20]) elif _ctl[29]+2 = 0 then error "cannot evaluate the solution past %1, hmin > hmax, maybe error tolerance is too small", evalf[8](_ctl[20]) elif _ctl[29]+3 = 0 then error "cannot evaluate the solution past %1, step size < hmin, problem may be singular or error tolerance may be too small", evalf[8](_ctl[20]) else error "cannot evaluate the solution past %1, unknown error code returned from dverk78: %2", evalf[8](_ctl[20]), _ctl[29] end if end if; if _Env_smart_dsolve_numeric = true then if _y0[0] < _ctl[17] and procname("right") < _ctl[17] then procname("right") := _ctl[17] elif _ctl[17] < _y0[0] and _ctl[17] < procname("left") then procname("left") := _ctl[17] end if end if end if; [_ctl[25], seq(_ycur[_i], _i = 1 .. _n)] end proc, (2) = Array(0..0, {}), (3) = [z, X(z), Y(z)], (4) = []}); _vars := _dat[3]; _pars := map(rhs, _dat[4]); _n := nops(_vars)-1; _solnproc := _dat[1]; if not type(_xout, 'numeric') then if member(x_dverk78, ["start", 'start', "method", 'method', "left", 'left', "right", 'right', "leftdata", "rightdata", "enginedata", "eventstop", 'eventstop', "eventclear", 'eventclear', "eventstatus", 'eventstatus', "eventcount", 'eventcount', "laxtol", 'laxtol', "numfun", 'numfun', NULL]) then _res := _solnproc(convert(x_dverk78, 'string')); if 1 < nops([_res]) then return _res elif type(_res, 'array') then return eval(_res, 1) elif _res <> "procname" then return _res end if elif member(x_dverk78, ["last", 'last', "initial", 'initial', "parameters", 'parameters', "initial_and_parameters", 'initial_and_parameters', NULL]) then _xout := convert(x_dverk78, 'string'); _res := _solnproc(_xout); if _xout = "parameters" then return [seq(_pars[_i] = _res[_i], _i = 1 .. nops(_pars))] elif _xout = "initial_and_parameters" then return [seq(_vars[_i+1] = [_res][1][_i+1], _i = 0 .. _n), seq(_pars[_i] = [_res][2][_i], _i = 1 .. nops(_pars))] else return [seq(_vars[_i+1] = _res[_i+1], _i = 0 .. _n)] end if elif type(_xout, `=`) and member(lhs(_xout), ["initial", 'initial', "parameters", 'parameters', "initial_and_parameters", 'initial_and_parameters', NULL]) then _xout := convert(lhs(x_dverk78), 'string') = rhs(x_dverk78); if type(rhs(_xout), 'list') then _res := _solnproc(_xout) else error "initial and/or parameter values must be specified in a list" end if; if lhs(_xout) = "initial" then return [seq(_vars[_i+1] = _res[_i+1], _i = 0 .. _n)] elif lhs(_xout) = "parameters" then return [seq(_pars[_i] = _res[_i], _i = 1 .. nops(_pars))] else return [seq(_vars[_i+1] = [_res][1][_i+1], _i = 0 .. _n), seq(_pars[_i] = [_res][2][_i], _i = 1 .. nops(_pars))] end if elif type(_xout, `=`) and member(lhs(_xout), ["eventdisable", 'eventdisable', "eventenable", 'eventenable', "eventfired", 'eventfired', "direction", 'direction', NULL]) then return _solnproc(convert(lhs(x_dverk78), 'string') = rhs(x_dverk78)) elif _xout = "solnprocedure" then return eval(_solnproc) elif _xout = "sysvars" then return _vars end if; if procname <> unknown then return ('procname')(x_dverk78) else _ndsol; _ndsol := pointto(_dat[2][0]); return ('_ndsol')(x_dverk78) end if end if; try _res := _solnproc(_xout); [seq(_vars[_i+1] = _res[_i+1], _i = 0 .. _n)] catch: error  end try end proc

(6)

dsol3(500)

Warning,  computation interrupted

 

NULL

NULL

``


 

Download dver.mw

 

how to evaulate the value of R(z) for different values of z=0 to 1 with an interval of 0.1 and print ten values  in one column

R(z):= 1-cos^2*(Pi*z);
 

Hi 
I am trying to expand a function f(t) in terms of fractional power series:
for example please see attached file tree.mw
 

``

restart

f := proc (x) options operator, arrow; exp(x) end proc:

alpha := 1/2:

N := 10:

f_approximate := proc (x) options operator, arrow; sum(a[i]*x^`i&alpha;`, i = 0 .. N) end proc


``


 

Download tree.mw

 

thanks 
    

Hello, to all,
On my computer I have installed Windows 7 Professional, Maple 2018.2.1 and
Physics:-Version()[2];
 2019, January 5, 13:32 hours, version in the MapleCloud: 276,

    version installed in this computer: 276
When I try to compute some examples from your poste "PDE_and_BC_during_2018.mw", I get an error in Example 8:
Example 8: This problem represents the temperature distribution in a thin circular plate whose lateral surfaces are insulated (Articolo example 6.9.2):
pde__8 := diff(u(r, theta, t), t) = (diff(u(r, theta, t), r)+r*(diff(u(r, theta, t), r, r))+(diff(u(r, theta, t), theta, theta))/r)/(25*r);
                                       /                    
                                       |                    
                                       |                    
                                       |                    
              d                    1   |/ d                \
   pde__8 := --- u(r, theta, t) = ---- ||--- u(r, theta, t)|
              dt                  25 r |\ dr               /
                                       \                    

                                      2                  \
                                     d                   |
                                  -------- u(r, theta, t)|
          /  2                \          2               |
          | d                 |    dtheta                |
      + r |---- u(r, theta, t)| + -----------------------|
          |   2               |              r           |
          \ dr                /                          /
iv__8 := D[1]*u(1, theta, t) = 0, u(r, 0, t) = 0, u(r, Pi, t) = 0, u(r, theta, 0) = (r-(1/3)*r^3)*sin(theta);
   iv__8 := D[1] u(1, theta, t) = 0, u(r, 0, t) = 0,

                                       /    1  3\           
     u(r, Pi, t) = 0, u(r, theta, 0) = |r - - r | sin(theta)
                                       \    3   /           
pdsolve([pde__8, iv__8], u(r, theta, t), HINT = boundedseries(r = [0]));
Error, (in dsolve) cannot determine if this expression is true or false: not 0 <= -Pi

or I get no answer as in Example 10:
Example 10: A Laplace PDE with one homogeneous and three non-homogeneous conditions:
pde__10 := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0;
                    /  2         \   /  2         \    
                    | d          |   | d          |    
         pde__10 := |---- u(x, y)| + |---- u(x, y)| = 0
                    |   2        |   |   2        |    
                    \ dx         /   \ dy         /    
iv__10 := u(0, y) = 0, u(Pi, y) = sinh(Pi)*cos(y), u(x, 0) = sin(x), u(x, Pi) = -sinh(x);
      iv__10 := u(0, y) = 0, u(Pi, y) = sinh(Pi) cos(y),

        u(x, 0) = sin(x), u(x, Pi) = -sinh(x)
pdsolve([pde__10, iv__10]);

There are also no answer as in Examle 10 in the Examples 15, 18, 19
Can you give me a hint,  what could be wrong?
With kind regards
Wolfgang Gellien

 

First 729 730 731 732 733 734 735 Last Page 731 of 2224