# Question:"Error, cannot split rhs into multiple assignment" when using function "Eigenvectors"

## Question:"Error, cannot split rhs into multiple assignment" when using function "Eigenvectors"

Maple 2016

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.

#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;

end proc

An example of an application of the procedure is