I need to calculate the eigenvalues and eigenvectors of a big marix with enough Digits. When i apply the command Eigenvectors(K,M) for this purpose, it takes approximately 40 min to be calculated by maple. Where only 1/4 of cores of my CPU is used in this computation.

How is it possible to use all of my CPU cores to calculate the eigenvalues and eigenvectors of a big matrix faster?

change the txt to m for the following files.

K.txt

M.txt

integration_doubt.mw
Hello all,

I am trying to solve for the first-order derivative of a function f2 w.r.t variable a when it is equated to 0. the function f2 is a summation of two integrals as shown in the file. Kindly help me if there is any way to obtain solutions without numerical settings. Can functionalities like the Leibnitz rule be done in MAPLE? Thanks for your advice/help. 

I have number 0.12

I use convert(0.12,string), result ".12" lost 0. Why?

Please help me @acer

I have a function with 3 variables fr2, fr3, and fr4. I want to find how this function varies with these variables in such a way that fr2+fr3+fr4 = 0.5.  All three variables are non-negatives. Please help me in generating a sensitivity report as fr2, fr3, and fr4 each varies across 0 to 0.5 in increments of 0.01 subject to their sum is equal to 0.5

Thank you.

The function is fn1 = 1.150000000*10^11*fr3 + 1.150000000*10^11*fr4 - 1.374950000*10^10 - 1.549500000*10^10*fr2

sensitivity_help.mw

to_minimize.mwto_minimize.mw

I have a function fn2 that I want to minimize. I'm not sure about the range of A. So I first want to check out if the function is convex or concave. Also need to find the optimum value of T w.r.t A for the fn2. But I'm not able to understand the solution, please help.

Dear respected colleagues,

The first "ex 1" and second "non linear" codes were sent to me by a colleague. It would be appreciated if they can be modified to look like the one saved with "K2 Nonlinear_Fang 2009". Thank you all for your time and best regards.

ex1.mw

non_linear.mw

K2_Nonlinear_Fang_2009.mw

Download data.mw

Hello all. I'm trying to solve the following first-order differential equation. 

Please help in understanding why the equation (6) doesn't contain proper solution for the function q(t) on solving the ode1 with the given initial condition

Dear esteem colleagues,

Please I am trying to plot a function using both implicitplot and contourplot. However, I found out that I have two different plots. What are the differences between them and perhaps which is better?

Thank you all for your time and best regards.

Hello everyone,

While trying to open a maple document, a box pops up with the text "How do you want to open this file?" with the options "Maple Text, Plain Text, Maple Inputs" what could be responsible for this? and which of the options is better for mathematics and coding?

Thank you so much

restart;
Digits:=30:

f:=proc(n)
	x[n]-y[n];
	
end proc:


e1:=y[n] = (15592/1575)*h*f(n+5)+(35618816/99225)*h*f(n+9/2)-(4391496/15925)*h*f(n+13/3)-(2035368/13475)*h*f(n+14/3)-(212552/121275)*h*f(n+1)+(10016/11025)*h*f(n+2)-(31672/4725)*h*f(n+3)+(19454/315)*h*f(n+4)-(351518/1289925)*h*f(n)+y[n+4]:
e2:=y[n+1] = -(34107/22400)*h*f(n+5)-(212224/3675)*h*f(n+9/2)+(92569149/2038400)*h*f(n+13/3)+(82333989/3449600)*h*f(n+14/3)-(568893/1724800)*h*f(n+1)-(459807/313600)*h*f(n+2)+(1189/22400)*h*f(n+3)-(50499/4480)*h*f(n+4)+(32951/6115200)*h*f(n)+y[n+4]:
e3:=y[n+2] = (69/175)*h*f(n+5)+(1466368/99225)*h*f(n+9/2)-(13851/1225)*h*f(n+13/3)-(60507/9800)*h*f(n+14/3)+(43/3675)*h*f(n+1)-(3509/9800)*h*f(n+2)-(6701/4725)*h*f(n+3)+(871/420)*h*f(n+4)-(247/396900)*h*f(n)+y[n+4]:
e4:=y[n+3] = -(31411/201600)*h*f(n+5)-(745216/99225)*h*f(n+9/2)+(13557213/2038400)*h*f(n+13/3)+(9737253/3449600)*h*f(n+14/3)-(20869/15523200)*h*f(n+1)+(36329/2822400)*h*f(n+2)-(202169/604800)*h*f(n+3)-(100187/40320)*h*f(n+4)+(14669/165110400)*h*f(n)+y[n+4]:
e5:=y[n+13/3] = -(3364243/1322697600)*h*f(n+5)-(134364928/651015225)*h*f(n+9/2)+(19955023/55036800)*h*f(n+13/3)+(5577703/93139200)*h*f(n+14/3)-(910757/101847715200)*h*f(n+1)+(1336457/18517766400)*h*f(n+2)-(2512217/3968092800)*h*f(n+3)+(31844549/264539520)*h*f(n+4)+(690797/1083289334400)*h*f(n)+y[n+4]:
e6:=y[n+14/3] = -(29107/10333575)*h*f(n+5)+(7757824/651015225)*h*f(n+9/2)+(180667/429975)*h*f(n+13/3)+(342733/2910600)*h*f(n+14/3)-(7253/795685275)*h*f(n+1)+(42467/578680200)*h*f(n+2)-(19853/31000725)*h*f(n+3)+(993749/8266860)*h*f(n+4)+(22037/33852791700)*h*f(n)+y[n+4]:
e7:=y[n+9/2] = -(115447/51609600)*h*f(n+5)-(21389/198450)*h*f(n+9/2)+(231041241/521830400)*h*f(n+13/3)+(43797591/883097600)*h*f(n+14/3)-(32833/3973939200)*h*f(n+1)+(48323/722534400)*h*f(n+2)-(91493/154828800)*h*f(n+3)+(1220071/10321920)*h*f(n+4)+(24863/42268262400)*h*f(n)+y[n+4]:
e8:=y[n+5] = (1989/22400)*h*f(n+5)-(61184/99225)*h*f(n+9/2)+(1496637/2038400)*h*f(n+13/3)+(2458917/3449600)*h*f(n+14/3)+(73/5174400)*h*f(n+1)-(31/313600)*h*f(n+2)+(359/604800)*h*f(n+3)+(1079/13440)*h*f(n+4)-(179/165110400)*h*f(n)+y[n+4]:



h:=0.01:
N:=solve(h*p = 8/8, p):
#N := 10:
#n:=0:
#exy:= [seq](eval(i+exp(-i)-1), i=h..N,h):
c:=1:
inx:=0:
iny:=0:

mx := proc(t,n):
   t + 0.01*n:
end proc:

exy := (x - 1.0 + exp(-x)):

vars := y[n+1],y[n+2],y[n+3],y[n+4],y[n+13/3],y[n+14/3],y[n+9/2],y[n+5]:

printf("%6s%20s%20s%20s\n", "h","numy1","Exact", "Error");
#for k from 1 to N/8 do
for c from 1 to N do

	par1:=x[n]=map(mx,(inx,0)),x[n+1]=map(mx,(inx,1)),
		x[n+2]=map(mx,(inx,2)),x[n+3]=map(mx,(inx,3)),
		x[n+4]=map(mx,(inx,4)),x[n+5]=map(mx,(inx,5)),
		x[n+13/3]=map(mx,(inx,13/3)),x[n+14/3]=map(mx,(inx,14/3)),
		x[n+9/2]=map(mx,(inx,9/2)):
	par2:=y[n]=iny:
	res:=eval(<vars>, fsolve(eval({e||(1..8)},[par1,par2]), {vars}));
	
	printf("%7.3f%22.10f%20.10f%17.3g\n", 
		h*c,res[8],(exy,[x=c*h]),abs(res[8]-eval(exy,[x=c*h]))):
		#c:=c+1:
	
	iny:=res[8]:
	inx:=map(mx,(inx,5)):
end do:

Dear all,

Please Kindly help to correct or modify the code above

Thank you and best regards
 

The rational expression at the beginning of the code is approximant. p1-p5 are conditions imposed on t, and are to be solved simultaneously to obtain a[0]-a[4] which are then substituted into t to obtain Cf. S1-S4 are to be obtained from Cf and its derivative.

However, I observed that Cf is not providing the desired results. What have I done wrong? Please Can someone be of help?

Thank you and kind regards

restart:
t:=sum(a[j]*x^j,j=0..2)/sum(a[j]*x^j,j=3..4):
F:=diff(t,x,x):
p1:=simplify(eval(t,x=q))=y[n]:
p2:=simplify(eval(t,x=q+h))=y[n+1]:
p3:=simplify(eval(F,x=q))=f[n]:
p4:=simplify(eval(F,x=q+h))=f[n+1]:
p5:=simplify(eval(F,x=q+2*h))=f[n+2]:
vars:= seq(a[i],i=0..4):
Cc:=eval(<vars>, solve({p||(1..5)}, {vars}));
for i from 1 to 5 do
	a[i-1]:=Cc[i]:
end do:
Cf:=t;
M:=diff(Cf,x):
s4:=y[n+2]=collect(simplify(eval(Cf,x=q+2*h)),[y[n],y[n+1],f[n],f[n+1],f[n+2]], recursive);
s3:=h*delta[n]=collect(h*simplify(eval(M,x=q)),{y[n],y[n+1],f[n],f[n+1],f[n+2]},factor);
s2:=h*delta[n+1]=collect(h*simplify(eval(M,x=q+h)),{y[n],y[n+1],f[n],f[n+1],f[n+2]},factor):
s1:=h*delta[n+1]=collect(h*simplify(eval(M,x=q+2*h)),{y[n],y[n+1],f[n],f[n+1],f[n+2]},factor):

Hi dear community!

The following code produces a table, however it always has the text "Tabulate0" as an output as well. Is it possible to supress that? Ordinary : dont work unfortunately.

with(DocumentTools):
with(ArrayTools):
nUnten:=2:
nOben:=8:
InitialisierungDF:=Vector[column](nOben-nUnten+1, fill=oE): #Erstellen der auszugebenden Tabelle
InitialisierungSpalte:=Vector[row](nOben-nUnten+1, i->n=nUnten-1+i):
DF:= DataFrame( Concatenate( 2, InitialisierungDF $ 10),
                   columns = [ GKAbs, GKRel, PZPAbs, PZPRel, PZMAbs, PZMRel, PYAbs, PYRel, DAbs, DRel],
                   rows = InitialisierungSpalte);
print(Tabulate(DF));

Thank you very much!

Hi there!

The first time I compile the following code, I get the error message

"Error, cannot split rhs into multiple assignment."

when trying to solve an issue with the procedure. I then have to compile the procedure over and over again, until it finally works (which it does eventually, without changing the code.) The problematic line is

Knoten, Eigenvektoren := Eigenvectors(evalf[15](M));

it is one of the last lines within the code below. Is it possible to get rid of that issue? It is annoying and unprofessional to have to compile a code over and over again until it finally works.

GaußKronrodQuadraturKurz:= proc(Unten, Oben, f,G,n)::real;
 
  #Unten:= Untere Intervallgrenze; Oben:= Obere Intervallgrenze; G:= Gewicht;
  #f:= zu untersuchende Funktion; n:= Berechnung der Knotenanzahl mittels 2*n+1
local
A,B,P,S,T, #Listen
a,b,p,s,t, #Listenelemente
i,j,k, #Laufvariablen
M, #werdende Gauss-Kronrod-Jacobi-Matrix
m, #Matrixeinträge
u,l, #Hilfsvariablen Gemischte Momente
RekursivesZwischenergebnis,Gewichte,Knoten,Eigenvektoren,AktuellerNormierterVektor,Hilfsvariable,Endergebnis;

with(LinearAlgebra):
 
A := [seq(a[i], i = 0 .. n)];
B := [seq(b[i], i = 0 .. n)];
P := [seq(p[i], i = -1 .. ceil(3*n/2)+1)];  
S := [seq(s[i], i = -1 .. floor(n/2))];
T := [seq(t[i], i = -1 .. floor(n/2))];
p[-1]:= 0;
p[0]:=1;
for i from -1 to floor(n/2) do
  s[i]:=0;
  t[i]:=0
end do;
for j from 1 to 2*n+1 do
  RekursivesZwischenergebnis:= x^j;
  for i from 0 to j-1 do
    RekursivesZwischenergebnis:= RekursivesZwischenergebnis -
    (int(x^j*p[i],x=Unten..Oben)/int(p[i]*p[i],x=Unten..Oben))*p[i]                  #Gram-Schmidt algorithm
  end do;
  p[j]:=RekursivesZwischenergebnis;
end do;
a[0]:=-coeff(p[1],x,0);

  #p[0+1]=(x-a[0])*p[0]-b[0]*p[0-1] -> p[1]=x*p[0]-a[0]*p[0]-b[0]*p[-1] ->
  #p[1]=x*1-a[0]*1-0 -> a[0]=x-p[1] -> a[0]= -coeff(p[1],x,0), da p[1] monisch ist und von Grad 1    #ist
 
b[0]:=int(p[0]^2, x=Unten..Oben); #by definition
for j from 1 to ceil(3*n/2) do
 
  #Genau genommen muss a nur bis floor(3/(2*n)) initialisiert werden, allerdings wird der Wert       #ohnehin für die Berechnung von b gebraucht. Die Initialisierung schadet nicht.
    
                                     
  a[j]:= coeff(p[j],x,j-1)- coeff(p[j+1],x,j);
    
    #p[j+1]=(x-a[j])*p[j]-b[j]*p[j-1] -> p[j+1]=x*p[j]-a[j]*p[j]-b[j]p[j-1] ->
    #coeff(p[j+1],x,j)=coeff(x*p[j],x,j)-coeff(a[j]*p[j],x,j)
      #(da b[j]*p[j-1] vom Grad j-1 ist) ->
    #coeff(p[j+1],x,j)=coeff(x*p[j],x,j)-a[j], da p[j] monisch ist ->
    #coeff(p[j+1],x,j)=coeff(p[j],x,j-1)-a[j]->
    #a[j]=coeff(p[j],x,j-1)-coeff(p[j+1],x,j)
 
  b[j]:=  quo((x-a[j])*p[j]-p[j+1],p[j-1],x);
    

     #p[j+1]=(x-a[j])*p[j]-b[j]*p[j-1] -> -p[j+1]+(x-a[j])*p[j]= b[j]*p[j-1]
     #b[j]=((x-a[j])*p[j]-p[j+1])/p[j-1]

end do;    
t[0]:=b[n+1]; #t[0]:= /hat{b}[0], Beginn der ostwärtigen Phase
for i from 0 to n-2 do # n-2 ist die Anzahl der zu berechnenden Diagonalen
  u:=0;
  for k from floor((i+1)/2) to 0 by -1 do # aufgrund des diagonalen Vorgehens ist nur bei jedem
                                          # zweiten Schleifendurchlauf eine Inkrementierung
                                          # vorzunehmen
    l:=i-k;
    u:=u+(a[k+n+1]-a[l])*t[k]+b[k+n+1]*s[k-1]-b[l]*s[k]; # Ausrechnen gemischter Momente über die
                                                         # fünfgliedrige Rekursion
    s[k]:=u
  end do;
  for j from -1 to floor(n/2) do  # Durchrotieren der Werte der gemischten Momente, da ein                                           # jeweiliges gemischtes Moment beim zweiten auf die Generierung                                    # folgenden
                                  # Schleifendurchlauf das letzte mal benötigt und danach über-
                                  # schrieben wird. Die am Ende vorliegenden Werte sind gerade
                                  # die, die bei der südwärtigen Phase benötigt werden.
    Hilfsvariable:=s[j];
    s[j]:=t[j];
    t[j]:=Hilfsvariable
  end do;
end do;
for j from floor(n/2) to 0 by -1 do
    s[j]:=s[j-1]
end do;
for i from n-1 to 2*n-3 do #entspricht der Anzahl der restlichen Diagonalen
  u:=0;
  for k from i+1-n to floor((i-1)/2) do #berechnet die gemischten Momente innerhalb einer
                                        #Diagonalen, von oben rechts nach unten links.
    l:=i-k;
    j:=n-1-l;
    u:=u-(a[k+n+1]-a[l])*t[j]-b[k+n+1]*s[j]+b[l]*s[j+1];
    s[j]:=u
  end do;
  if i mod 2 = 0 then #Ausrechnen eines fehlenden Koeffizienzen über die fünfgliedrige Rekursion                         #am Eintrag (k,k)
    k:= i/2;
    a[k+n+1]:=a[k]+(s[j]-b[k+n+1]*s[j+1])/t[j+1]
  else                #Ausrechnen eines fehlenden Koeffizienzen über die fünfgliedrige Rekursion                         #am Eintrag (k,k-1)
    k:=(i+1)/2;
    b[k+n+1]:=s[j]/s[j+1]
  end if;
  for j from -1 to floor(n/2) do #Erneutes Durchrotieren der Werte der gemischten Momente
    Hilfsvariable:=s[j];
    s[j]:=t[j];
    t[j]:=Hilfsvariable
  end do;
end do;
a[2*n]:=a[n-1]-b[2*n]*s[0]/t[0]; #Berechnung des letzten fehlenden Koeffizienten über die                                           #fünfgliedrige Rekursion am Eintrag (n-1,n-1)

M:=Matrix(2*n+1, shape=symmetric);#definieren der werdenden Gauß-Krondrod-Matrix
M(1,1):=a[0];
for m from 2 to (2*n+1) do #generieren der Gauss-Kronrod-Matrix
  M(m-1,m):= sqrt(b[m-1]);
  M(m,m-1):= sqrt(b[m-1]);
  M(m,m):= a[m-1];
end do;
Knoten, Eigenvektoren := Eigenvectors(evalf[15](M));# "Die gesuchten Knoten sind die Eigenwerte #dieser Matrix, und die Gewichte sind proportional zu den ersten Komponenten der normalisierten #Eigenvektoren"

for m from 1 to 2*n+1 do
  AktuellerNormierterVektor:= Normalize(Column(Eigenvektoren,m),Euclidean);
 
 
  Gewichte[m]:=AktuellerNormierterVektor[1]^2*b[0]

end do;

Endergebnis:=Re(add(Gewichte[i]*eval(f*diff(G,x),x=Knoten[i]),i=1..2*n+1));

end proc

An example of an application of the procedure is

GaußKronrodQuadraturKurz(-2, 1, 3*x*3*x^2*sin(x),x,3)

Thank you very much!

HI all, I obtained a solution to a system solved by Maple but it seems not to be correct. And I couldn't detect where the mistake lies!

solution_bug_or.....mw

Hello everyone!

I want to construct column vector which elements should be square matrices (m x n each one). So, i use cycle "for" to set such construction.

My question is: what is the fastest way to construct matrices if each matrix elements are independent from each other and also they are results of numerical integration, like is shown in attached file?

Acceleration.mw