d nacional de san Agustn escuela profesional de ingenier

DOCENTE: ING. LUIS MERCADO

ALUMNO: QUICAO QUISPE JESUS
CUI: 20101583
CURSO: LAB. DE CONTROL 1

Laboratorio 2
Modelacin de sistemas utilizando MATLAB
2.1. Objetivos.

Modelar sistemas lineales invariantes en el tiempo.

Utilizar los diferentes comandos que proporciona MATLAB para
realizar simulaciones de sistemas de control.
Utilizar herramientas computacionales provistas por MATLAB para
la conexin, conversin de modelos LTI.

2.2. Marco terico.MATLAB trabaja esencialmente con matrices numricas rectangulares

(que pueden tener elementos complejos), lo cual implica el uso de
vectores fila o columna. Por esta razn este paquete tiene una
proyeccin hacia el control moderno (descrito a variables de estado) y
es til para ilustrar las relaciones existentes entre las tcnicas clsicas
y modernas de anlisis. Para ello, contiene un conjunto de rutinas de
propsito general que permite modelar, analizar y simular cualquier
tipo d sistema, adems, es capaz de trabajar con modelos lineales
invariantes en el tiempo (LTI), los cuales son:

TF : modelo a funcin de transferencia

ZPK : modelo ceros polos ganancia
SS : modelo a espacio de estados
FRD : modelo de respuesta a frecuencia

MATLAB realiza las diversas conexiones y conversiones entre este

conjunto de modelos.
2.2.1.

Funciones para la Conexin de Modelos LTI utilizando

MATLAB.-

La librera de sistemas de control de Matlab cuenta con un conjunto de

funciones para interconectar modelos para desarrollar concatenaciones
de entrada salida, colocarlos en serie, paralelo y con realimentacin.
2.2.1.1. Conexin Serie.sys = series(sys1,sys2)
conecta en serie dos modelos:

Es equivalente a multiplicacin: sys = sys2 * sys1

sys = series(sys1,sys2,outputs1,inputs2)
permite la siguiente conexin:

En donde outputs1 e inputs2 indican cuales salidas y1 de sys1 y cuales

entradas u2 de sys2 deben ser conectadas. El modelo sys resultante
tiene como entrada u y como salida y.
2.2.1.2. Conexin con Realimentacin.Considerando que el sistema de control realimentado es aquel que
tiende a mantener una relacin preestablecida entre la salida y alguna
entrada de referencia, comparndolas y utilizando la diferencia como
medio de control. Matlab permite realizar dicha realimentacin con los
siguientes comandos:
sys = feedback(sys1,sys2)
El modelo en lazo cerrado sys tiene un vector de entrada y otro de
salida, y esta funcin determina una realimentacin negativa como la
de la figura. Los modelos sys1 y sys2 deben ser continuos.

sys = feedback(sys1,sys2,feedin,feedout)
en la mayora de sistemas de control realimentado es comn la
presencia de perturbaciones o seales que tienden a afectar
adversamente el valor de la salida, pueden ser internas o externas. Esto
implica seales que ingresan al sistema, pero que no se realimentan,
as:

El vector feedin contiene ndices dentro del vector de entrada de sys1 y

especifica cuales entradas u son afectadas en el lazo de realimentacin.
Similarmente, feedout especifica cuales salidas y de sys1 son usadas en
la realimentacin. El modelo LTI resultante sys tiene el mismo numero
de entradas y salidas que sys1.
2.2.1.3. Conexiones mas frecuentes en Sistemas de Control.Cuando el comportamiento dinmico de un sistema no es satisfactorio,
esto es, no cumple las especificaciones de respuesta transitoria y en
estado estable a fin de obtener un funcionamiento satisfactorio es
posible utilizar, compensacin en serie, que abreves rasgos implica
colocar en serie con la planta un compensador cuya funcin de
transferencia Gc puede implicar desde una variacin de ganancia hasta
complejas redes de adelanto y atraso, etc. Esto es posible siempre y
cuando exista realimentacin de tal forma que G c procese la seal de
error. Las conexiones ms comunes en los sistemas de control clsicos
son:
Compensador

Planta

GC(s)

G(s)

R(s)

Y(s)
H(S)
Compensacin en Serie
G1(s)

G(s)

R(s)

Y(s)
Gc(s)
H(s)

Compensacin de Retroalimentacin o en Paralelo

Generalmente, en el anlisis y diseo de sistemas de control se ha de

tener una base de comparacin del desempeo de diversos sistemas de
control, la misma que se configura especificando las seales de entrada
de prueba particulares y comparando las respuestas de varios sistemas
a estas seales de entrada. MATLAB permite utilizar seales de prueba
tpicas para comparar sistemas, como seales paso, rampa, etc. Esta
funcin reproduce una figura con la respuesta de sys a la entrada Paso:
step(sys)
2.2.2.

% Respuesta Escaln Unitario (paso)

Funciones para la Conversin de Modelos LTI utilizando

MATLAB.-

Existen cuatro tipos de modelos linealmente invariantes en el tiempo

LTI que pueden utilizarse con la librera de Sistemas de Control, que son
TF (funcin de transferencia), ZPK (ceros, polos y ganancia), SS (espacio
de estados) y FRD (respuesta en frecuencia). Es posible realizar la
conversin de un modelo a otro, en forma explicita, para un modelo
dado sys con la siguiente sintaxis:
sys
sys
sys
sys

=
=
=
=

tf(sys)
% Conversin a TF
zpk(sys)
% Conversion a ZPK
ss(sys)
% Conversion a SS
frd(sys, frequency)
% Conversion a FRD

para el ltimo caso, frequency es un vector de frecuencias usada como

argumento e entrada cuando se realiza la conversin al modelo FRD.
Por ejemplo:
Un modelo de espacio estados, para convertirse a un modelo ZPK:
sys = ss(-2,1,1,3)
zpk(sys)

s 2.333
s2

Matlab en ocasiones realiza conversiones automticas ya que existen

varios comandos que requieren de un modelo especfico como
parmetro de entrada as que antes de realizar la funcin indicada por
el comando realiza la conversin. Estas conversiones pueden ser
utilizadas tanto para sistemas sencillos con una nica entrada y nica
salida (SISO) como para sistemas de mltiples entradas y salidas
(MIMO).

2.2.3.

Conversin Continua/Discreta para modelos LTI.-

Los sistemas de control discreto difieren de los sistemas de control en

tiempo continuo en que las seales en uno o ms puntos del sistema
son, ya sea en forma de pulsos o un cdigo digital. Pueden ser sistemas
de control de datos muestreados y de control digital, en el primer caso,
el sistema nicamente recibe datos o informacin intermitente en
instantes especficos, mientras que para el segundo caso implica el uso
de una computadora o un controlador digital en el sistema. Es posible
encontrar el equivalente discreto de una planta a fin de implementar un
control digital, trabajando en el dominio de z, con un tiempo de
muestreo adecuado.
Para discretizar de los modelos invariantes en el tiempo TF, SS o ZPK,
es posible utilizar la instruccin:
sysd = c2d(sysc,Ts,metodo)
Donde:
sysd = sistema discreto
sysc = sistema continuo
Ts = periodo de muestreo en segundos
sysc = sistema continuo en el tiempo
Donde mtodo es el procedimiento de discretizacion y puede ser:
zoh

retenedor de orden cero

foh

retenedor de primer orden

imp
tustin

Discretizacion de impulso invariante

Aproximacin Bilinear Tustin

matched Mapeo de Polos y Ceros

Por defecto cuando el mtodo es omitido se usa el zoh.
Viceversa, para convertir un sistema discreto a uno continuo:
sysc = d2c(sysd,metodo)

En forma similar el mtodo de conversin utilizara el equivalente propio

de zoh, tustin, o matched.
as como para los sistemas continuos en el tiempo se ingresan seales
singulares para conocer el desempeo del mismo, aqu se usa por
ejemplo, la seal paso discreta, con la siguiente instruccin:
step(sysd)

% sysd = planta discretizada

2.3. Trabajo Preparatorio.Se tiene un circuito serie RLC alimentado por una fuente v(t) entrada y Vc(t) tensin
en el capacitor de salida

2.3.1.
-

Obtener la ecuacin diferencial que define el sistema

Para la obtencin de la ecuacin diferencial hacemos una malla en

el circuito resultando:

V ( t )=Ri (t ) +
-

Ldi ( t ) 1
+ i(t)dt
dt
C

Luego:

i ( t )=

dq(t)
dt
2

di ( t ) d q(t)
= 2
dt
dt

i(t)dt=q(t)
-

Reemplazando en la ecuacin:

Rdq ( t ) Ld q ( t ) 1
V ( t )=
+
+ q(t)
2
dt
C
d t
-

La ecuacin diferencial resulta:

1
V ( t )=Rq ' (t)+Lq ' '(t)+ q (t)
C
2.3.2.

Obtener la funcin de transferencia del sistema.

FT=
-

Haciendo sumatoria de voltajes:

V ( t )=Ri (t ) +
-

Ldi ( t )
+Vc ( t ) (1)
dt

Hallando el voltaje en el capacitor:

Vc ( t )=
-

Vc (t)
V (t)

1
i(t)dt (2)
C

Hallando la transformada de Laplace de (1) y (2)

V ( s )=RI ( s ) +LSI ( s ) +Vc (s)

(3)

1
1
(4)
C
Vc ( s )=
I (s)
S
-

Despejando I(s) de (4) y reemplazando en (3)

I ( s )=CSVc (s)

V ( s )=I ( s )( R+LS ) +Vc (s)

V ( s )=CSVc ( s )( R+LS ) +Vc(s)

V ( s )=Vc ( s )(CS( R+LS ) +1)

-

La funcin de transferencia ser:

Vc (t)
1
=
V (t ) CS( R+ LS ) +1
2.3.3.

Obtener analticamente el modelo en variables de

estado.

Aplicando las Leyes de Kirchhoff:

V ( t )=Ri (t ) +
i ( t )=
-

Ldi ( t )
+Vc ( t )
dt

CdVc ( t )
dt
Organizando las ecuaciones:

di ( t ) R
1
1
= i (t ) Vc ( t )+ V (t)
dt
L
L
L

dVc ( t ) 1
= i(t )
dt
C
-

En forma matricial:

[ ] [ ][

di ( t )
R 1

1
dt = L L i ( t ) +
L [ V (t) ]
1
dVc ( t )
Vc
(
t
)
0
0
C
dt

][

2.3.4. Obtener analticamente Vc(t) para una entrada escaln

unitario para valores de R, L y C asumidos por el estudiante.
(Ntese que la entrada paso es la integral de una entrada
impulso).
- Se tienen los valores de R=20, L=0.5h y C=0.01F
-

De la parte 2.3.2 se tiene que la funcin de transferencia ser:

Vc (t)
1
=
V (t ) CS( R+ LS ) +1
-

Reemplazando los valores de R, L y C

Vc (t)
200
=
2
V (t ) 0.005 S +0.2 S+200
-

Luego de la funcin de transferencia

n=1
-

Hallando las especificaciones de respuesta del sistema:

0.2=2n
=

0.2
21

=
d=n 1

0.1

d=0.995
tr=

1
d
tan1
d
n

( )

tr=0.0015
tp=

tp=3.1574

Mp=e

1 2

Mp=1.371
T=

1
n

T =10

ts=4T
ts=40

Valores Y
3.5
3
2.5
Valores Y

2
1.5
1
0.5
0
0.5

1.5

2.5

2.4 Trabajo Experimental

2.4.1 Obtenga el modelo en espacio de estado, zpk, respuesta
en frecuencia si es posible del sistema del trabajo preparatorio.
SS: Modelo a espacios estados
%Modelo a espacios de Estados
clc
L=input('ingrese un valor para L=');
C=input('ingrese un valor para C=');
R=input('ingrese un valor para R=');
num=[1];
den=[L*C R*C 1];
A=tf(num,den);
Ass=ss(A)
ingrese un valor para L=0.3
ingrese un valor para C=0.3
ingrese un valor para R=20
a =
x1
x2
x1 -66.67
x2
4
b =
u1

-2.778
0

x1
x2

2
0

c =
x1

x2
y1

1.389

d =
y1

u1
0

Continuous-time model.
ZPK: Modelo ceros-polos-ganancia
%Modelo a ceros-polos-ganancia
clc
L=input('ingrese un valor para L=');
C=input('ingrese un valor para C=');
R=input('ingrese un valor para R=');
num=[1];
den=[L*C R*C 1];
B=tf(num,den);
Bzp=zpk(B)
ingrese un valor para L=0.3
ingrese un valor para C=0.3
ingrese un valor para R=20
Zero/pole/gain:
11.1111
------------------(s+66.5) (s+0.1671)
FRD: Modelo de respuesta de Frecuencia
%Modelo respuesta de frecuencia
clc
L=input('ingrese un valor para L=');
C=input('ingrese un valor para C=');
R=input('ingrese un valor para R=');
num=[1];
den=[L*C R*C 1];
B=tf(num,den);
Bfr=frd(B,3)
Ingrese un valor para L=0.3
Ingrese un valor para C=0.3
Ingrese un valor para R=20
Frequency(rad/s)
----------------

Response
--------

5.864e-004 - 0.0555i

Continuous-time frequency response.

2.4.2 Obtener la respuesta en lazo abierto y cerrado para las
entradas: impulso, paso, rampa, senoidal

Lazo Abierto
ENTRADA IMPULSO

Impulse Response

0.18
0.16
0.14
0.12

Am plitude

%Entrada Impulso
clc
L=input('ingrese un valor para
L=');
C=input('ingrese un valor para
C=');
R=input('ingrese un valor para
R=');
num=[1];
den=[L*C R*C 1];
I=tf(num,den);
impulse(I)

0.1
0.08
0.06
0.04
0.02

ingrese un valor para L=0.3

ingrese un valor para C=0.3
ingrese un valor para R=20

10

15

20

25

30

35

40

Time (sec)

ENTRADA PASO

ingrese un valor para L=0.3

ingrese un valor para C=0.3
ingrese un valor para R=20

Linear Simulation Results

10
9
8
7
6
Amplitude

%Entrada Paso
clc
L=input('ingrese un valor para
L=');
C=input('ingrese un valor para
C=');
R=input('ingrese un valor para
R=');
num=[1];
den=[L*C R*C 1];
I=tf(num,den);
step(I)

5
4
3
2
1
0

5
Time (sec)

ENTRADA RAMPA

10

%Entrada Rampa
clc
L=input('ingrese un valor
para L=');
C=input('ingrese un valor
para C=');
R=input('ingrese un valor
para R=');
num=[1];
den=[L*C R*C 1];
I=tf(num,den);
t=0:0.3:10;
u=t;
lsim(I,u,t)

Step Response

1
0.9
0.8
0.7

Amplitude

0.6
0.5
0.4
0.3

ingrese un valor para L=0.3

ingrese un valor para C=0.3
ingrese un valor para R=20

0.2
0.1
0

10

15

20
Time (sec)

ENTRADA SENOIDAL

ENTRADA SENOIDAL
%Entrada Senoidal
clc
L=input('ingrese un valor para L=');
C=input('ingrese un valor para C=');
R=input('ingrese un valor para R=');
num=[1];
den=[L*C R*C 1];
I=tf(num,den);
t=0:0.3:10;
u=sin(t);
lsim(I,u,t)
ingrese un valor para L=0.3
ingrese un valor para C=0.3
ingrese un valor para R=20

25

30

35

40

Linear Simulation Results

1
0.8
0.6
0.4

Amplitude

0.2
0
-0.2
-0.4
-0.6
-0.8
-1

10

Time (sec)

Lazo Cerrado

ENTRADA IMPULSO

ingrese un valor para L=0.3

ingrese un valor para C=0.3
ingrese un valor para R=20

Impulse Response

0.18
0.16
0.14
0.12
Amplitude

%Entrada Impulso
clc
L=input('ingrese un valor
para L=');
C=input('ingrese un valor
para C=');
R=input('ingrese un valor
para R=');
num=[1];
den=[L*C R*C 1];
I=tf(num,den);
feedback(I,1);
impulse(I)

0.1
0.08
0.06
0.04
0.02
0

10

15

20
Time (sec)

ENTRADA PASO

%Entrada Paso
clc
L=input('ingrese un valor para L=');

25

30

35

40

C=input('ingrese un valor para C=');

R=input('ingrese un valor para R=');
num=[1];
den=[L*C R*C 1];
P=tf(num,den);
P=feedback(P,1);
step(P)
ingrese un valor para L=0.3
ingrese un valor para C=0.3
ingrese un valor para R=20

Step Response

0.5
0.45
0.4
0.35

Amplitude

0.3
0.25
0.2
0.15
0.1
0.05
0

10

12

Time (sec)

ENTRADA RAMPA

%Entrada Rampa
clc
L=input('ingrese un valor para L=');
C=input('ingrese un valor para C=');
R=input('ingrese un valor para R=');
num=[1];
den=[L*C R*C 1];
P=tf(num,den);
P=feedback(P,1);
t=0:0.3:10;
u=t;
lsim(P,u,t)

14

16

18

ingrese un valor para L=0.3

ingrese un valor para C=0.3
ingrese un valor para R=20

Linear Simulation Results

10
9
8
7

Amplitude

6
5
4
3
2
1
0

Time (sec)

ENTRADA SENOIDAL

%Entrada Senoidal
clc
L=input('ingrese un valor para L=');
C=input('ingrese un valor para C=');
R=input('ingrese un valor para R=');
num=[1];
den=[L*C R*C 1];
P=tf(num,den);
P=feedback(P,1);
t=0:0.3:10;
u=sin(t);
lsim(P,u,t)
ingrese un valor para L=0.3
ingrese un valor para C=0.3
ingrese un valor para R=20

10

Linear Simulation Results

1
0.8
0.6
0.4

Amplitude

0.2
0
-0.2
-0.4
-0.6
-0.8
-1

10

Time (sec)

2.4.3 Obtenga la ecuacin diferencial que representa al sistema

y la funcin de transferencia del siguiente circuito

Su ecuacin diferencial es:

i= IR 1+ I 1R 2
e

1
idt=e 0
c

Se toma la transformada de laplace:

I(s)R1+

I1

(s)R2

Ei (s)

I=

I 1 +I 2

11
cs

I2

(s)

E0 (s)

E0
R2
=
E i R 1 R 2 CS+R 1+R 2

2.5 Informe
2.5.1 presente los resultados
2.5.2 Empleando lazos y estructuras de control de flujo,

elabore un programa que permita obtener sobre un mismo

grafico l respuesta escalon en lazo abierto para cinco
valores diferentes del parmetro a del sistema dado por la
siguiente funcin de transferencia

G ( S )=

a
s+4

%Respuesta en escalon para cinco valores diferentes

clc
for i=6:1:10
num=[i];
den=[1 4];
G=tf(num,den);
step(G)
holdon
end

Step Response

2.5

A m p litu d e

1.5

0.5

0.5

1.5

Time (sec)

PROGRAMA EN MATLAB SOBRE LA FORMULA DE

MASON
function [Num,Den] = mason(NetFile,Start,Stop)
fid=fopen(NetFile); if (fid==-1)
fprintf('\n*** File, %s, not found ***\n\n',NetFile)
return
end
Net=[]; line_number=0; Coeff_Names={}; while 1 line_number=line_number+1; x=fscanf(fid,'%d',3);
Coeff=fscanf(fid,'%s\n',1);
if isempty(x) break
end
Net(line_number,:)=transpose(x);
Coeff_Names{line_number}= Coeff;
end
fclose(fid);
temp=size(Net);
Number_Coeff=temp(1);
[PathCoeffList,PathNodeList]=findpaths(Start,Stop,[],[],Net);
LoopCoeffList=[];
LoopNodeList=[];
for index=1:Number_Coeff;
[FoundLoops,FoundNodes]=findpaths(index,index,[],[],Net);
LoopCoeffList=[LoopCoeffList;FoundLoops]; LoopNodeList=[LoopNodeList;FoundNodes]; end
[LoopCoeffList,LoopNodeList]=RemoveDuplicateLoops(LoopCoeffList,LoopNodeList);
temp=size(PathCoeffList);
NumberPaths=temp(1);
if (NumberPaths==0);
fprintf('\n*** There are no paths connecting those nodes ***\n')
return
end

for index=1:NumberPaths
Coeff=PathCoeffList(index,:);
P{index}.Coeff=Coeff(1:sum(Coeff>0));
Node=PathNodeList(index,:);
P{index}.Node=[Node(1:sum(Coeff>0)),Stop];
end
temp=size(LoopCoeffList);
NumberLoops=temp(1);
L{1}.NumberLoops=NumberLoops;
for index=1:NumberLoops
Coeff=LoopCoeffList(index,:);
L{1}.Coeff{index}=Coeff(1:sum(Coeff>0));
Node=LoopNodeList(index,:);
L{1}.Node{index}=[Node(1:sum(Coeff>0)),Node(1)];
end
=1;
while 1
n=n+1;
L{n}.NumberLoops=0;
for first=1:L{1}.NumberLoops
for second=1:L{n-1}.NumberLoops
if not(AreTouchingLoops(L{1}.Node{first},L{n-1}.Node{second}))
Duplicate=0;
for index=1:L{n}.NumberLoops
if IsSameLoop([L{1}.Coeff{first}, L{n-1}.Coeff{second}],L{n}.Coeff{index})
Duplicate=1;
end
end
if (Duplicate==0)
L{n}.NumberLoops=L{n}.NumberLoops+1;
L{n}.Coeff{(L{n}.NumberLoops)}=[L{1}.Coeff{first}, L{n-1}.Coeff{second}];
L{n}.Node{(L{n}.NumberLoops)}=[L{1}.Node{first}, L{n-1}.Node{second}];
end
end
end
end
if (L{n}.NumberLoops==0)
break
end
end
fprintf('\n-- Network Info --\n')
fprintf('Net File : ');fprintf(NetFile);fprintf('\n');
fprintf('Start Node : %d\n',Start);
fprintf('Stop Node : %d\n',Stop);
fprintf('\n----- Paths -----\n')
for pathn=1:length(P)
fprintf('P%d : ',pathn);
fprintf('%d ',P{pathn}.Coeff);
fprintf('\n');
end
for loop_order=1:length(L)-1
fprintf('\n- Order %d Loops -\n',loop_order)
for loop_number=1:L{loop_order}.NumberLoops
fprintf('L%d%d : ',loop_order,loop_number)
fprintf('%d ',L{loop_order}.Coeff{loop_number})
fprintf('\n')
end
end
Num='';

for pathn=1:length(P)
Num=sprintf('%s%s*(1', Num, CoeffToString(P{pathn}.Coeff)); % Pn*(1 ..
for order=1:length(L)-1
if (rem(order,2)==1)
Num=sprintf('%s-',Num);
else
Num=sprintf('%s+',Num);
end
Num=[Num,PrintSumsNotTouching(L,order,P{pathn}.Node)];
end
Num=sprintf('%s)+',Num); %
end
Num=Num(1:length(Num)-1);
Den='1';
for order=1:length(L)-1 %
if (rem(order,2)==1)
Den=sprintf('%s-',Den);
else
Den=sprintf('%s+',Den);
end
Den=[Den,PrintSumsNotTouching(L,order,[9999999 999999])];
end
fprintf('\nThe variables returned are strings describing\n')
fprintf('the numerator and Denominator of the transfer equation.\n')
fprintf('If you have the symbolic toolbox, use Denominator=sym(Denominator)\n');
fprintf('and Numerator=sym(Numerator) to make these symbolic equations.\n')
fprintf('You can now use simple(Numerator/Denominator) to boil the whole\n')
fprintf('thing down. You could also use simple(Numerator) to simplify the\n')
fprintf('Numerator on it'' own.\n\n')
for coeff_num=length(Coeff_Names):-1:1;
orig=sprintf('c%d',Net(coeff_num,1));
Den=strrep(Den,orig,Coeff_Names{coeff_num});
Num=strrep(Num,orig,Coeff_Names{coeff_num});
end %
function Touching=AreTouchingLoops(Nodes1,Nodes2)
Loop1Length=sum(Nodes1>0);
Loop2Length=sum(Nodes2>0);
for first=1:Loop1Length
for second=1:Loop2Length
if (Nodes1(first)==Nodes2(second))
Touching=1;
return;
end
end
end
Touching=0;
function StrMult=CoeffToString(Coefficients)
N=length(Coefficients);
StrMult=sprintf('c%d',Coefficients(1));
for n=2:N
StrMult=[StrMult, sprintf('*c'),sprintf('%d',Coefficients(n))];
end
function [PathUp,NodesUp]=findpaths(StartNode,StopNode,Path,Nodes,Net)
temp=size(Net);
NumberCoeff=temp(1,1);
PathUp=[];
NodesUp=[];
for index=1:NumberCoeff

if not(isempty(Nodes))
if (sum(Nodes==index)>1)
PathUp=[];
return
end
end
end
if ((StartNode==StopNode) & (length(Path>1)))
PathUp=Path;
NodesUp=Nodes;
return
end
for index=1:NumberCoeff
if (StartNode==Net(index,2))
[FoundPath,FoundNodes]=findpaths(Net(index,3),StopNode,[Path,Net(index,1)],
[Nodes,StartNode],Net);
if not(isempty(FoundPath))
PathUp=[PathUp;[FoundPath,zeros(1,NumberCoeff+1-length(FoundPath))]];
NodesUp=[NodesUp;[FoundNodes,zeros(1,NumberCoeff+1-length(FoundPath))]];
end
end
end
function Same=IsSameLoop(Loop1,Loop2)
Loop1Length=sum(Loop1>0);
Loop2Length=sum(Loop2>0);
if (Loop1Length~=Loop2Length)
Same=0;
return
end
if (sum(abs(sort(Loop1)-sort(Loop2)))==0)
Same=1;
else
Same=0; %
function Str=PrintSumsNotTouching(L,order,Pnodes)
No_NonTouching=1;
Str=('(');
for n=1:L{order}.NumberLoops
if not(AreTouchingLoops(Pnodes,L{order}.Node{n})) Str=sprintf('%s
%s+',Str,CoeffToString(L{order}.Coeff{n}));
No_NonTouching=0; %
end
end
Str=Str(1:(length(Str)-1));
Str=sprintf('%s)',Str);
if No_NonTouching==1
end
function [LoopList,NodeList]=RemoveDuplicateLoops(LoopList,NodeList);

temp=size(LoopList);
NumberLoops=temp(1);
first=1;
while (first<=NumberLoops)
second=first+1;
while (second<=NumberLoops)
if (IsSameLoop(LoopList(first,:),LoopList(second,:))==1)
LoopList=[LoopList(1:second-1,:);LoopList(second+1:NumberLoops,:)];
NodeList=[NodeList(1:second-1,:);NodeList(second+1:NumberLoops,:)];
NumberLoops=NumberLoops-1;
else
second=second+1;
end
first=first+1;
end