Cusco, 25 de julio del 2020

Temario:

1. Fundamentos del lenguaje

- Interfaz del programa
- Entrada de comandos, construir y ejecutar sentencias MATLAB
- Matrices y arreglos (Operadores y operaciones elementales)
- Tipos de datos
- Bucles y declaraciones condicionales
2. Gráficos
- Gráficos 2D y 3D
- Formato y anotación
- Objetos gráficos
3. Análisis de datos
- Importación y exportación de datos
- Preprocesamiento de datos
- Estadísticas descriptivas
- Exploración visual
4. Programación
- Scripts
- Funciones
- Live Scripts
 Conceptos generales: Interfaz del programa

# Ventanas
1 Current folder
2 Editor
Dirección carpeta de trabajo 3 Command History
4 Workspace
5 Command Windows
1 2

4 5
 Conceptos generales: Interfaz del programa
Barra de Menús.

Archivos Variables workspace Variables workspace Visualización entorno ayuda

Menú de gráficas
Conceptos generales: Interfaz del programa
Conceptos generales: Interfaz del programa

Apps
Conceptos generales: Interfaz del programa

Library Compiler
Conceptos generales: Interfaz del programa

Add-Ons -Explorer
 1. Fundamentos del lenguaje: Entrada de comandos, construir y ejecutar sentencias MATLAB

Style Resultado Ejemplo

Entrada de comandos, construir y ejecutar sentencias MATLAB short Formato corto y decimal fijo con 4 3.1416
(default) dígitos después del punto decimal.
ans Respuesta más reciente long Formato decimal fijo y largo con 15 3.141592653589793
dígitos después del punto decimal para
clc Borrar ventana de comandos los valores de double y 7 dígitos después
del punto decimal para los valores
diary Registrar el texto de la ventana de comandos en el archivo de single .
format Establecer el formato de visualización de salida de la ventana de shortE Notación científica corta con 4 dígitos 3.1416e+00
después del punto decimal.
comandos longE Notación científica larga con 15 dígitos 3.141592653589793e+00
home Enviar cursor a casa después del punto decimal para los
valores de double y 7 dígitos después del
iskeyword Determine si la entrada es la palabra clave MATLAB punto decimal para los valores de single .
more Controlar la salida paginada en la ventana de comandos shortG Formato corto, fijo decimal o notación 3.1416
científica, cualquiera que sea más
Command Window Seleccione la ventana de comandos compacto, con un total de 5 dígitos.
longG Formato decimal largo, fijo o notación 3.14159265358979
Command History Window Abrir ventana de historial de comandos científica, cualquiera que sea más
compacto, con un total de 15 dígitos
pi para los valores de double y 7 dígitos
formart long para los valores de single .
pi shortEng Notación de ingeniería corta (exponente 3.1416e+000
format longE es un múltiplo de 3) con 4 dígitos
pi después del punto decimal.
format rat longEng Notación de ingeniería larga (exponente 3.14159265358979e+000
pi es un múltiplo de 3) con 15 dígitos
ans = ans = significativos.
+ Formato positivo/negativo con +, -y +
3.1416 3.141592653589793 caracteres en blanco mostrados para
elementos positivos, negativos y cero.
bank Formato de moneda con 2 dígitos 3.14
ans = ans = después del punto decimal.
hex Representación hexadecimal de un 400921fb54442d18
3.141592653589793e+00 355/113 número binario de doble precisión.
rat Proporción de números enteros 355/113
pequeños.
 1. Fundamentos del lenguaje: Entrada de comandos, construir y ejecutar sentencias MATLAB

Comandos de ayuda
help Busca información de las funciones en el command windows
doc Documentación, ayuda de Matlab
Conceptos generales: Interfaz del programa

Comandos de ayuda: doc

 1. Fundamentos del lenguaje : Matrices y Arreglos
Concepto: Determinar tamaño, forma y orden
Las matrices y los arreglos son la representación
fundamental de la información y los datos en MATLAB. length Longitud de la mayor dimensión de matriz
Puede crear matrices y cuadrículas comunes, combinar size Tamaño de la matriz
matrices existentes, manipular la forma y el contenido de ndims Número de dimensiones de la matriz
una matriz y utilizar la indexación para acceder a los numel Número de elementos de matriz
elementos de la matriz. isscalar Determinar si la entrada es escalar
Crear y combinar matrices issorted Determinar si la matriz está ordenada
zeros Crea una matriz de ceros issortedrows Determine si las filas de la matriz o la tabla están ordenadas
ones Crea una matriz de unos isvector Determinar si la entrada es vector
rand Crea una matriz aleatoria ismatrix Determinar si la entrada es matriz
true Matriz Lógica 1 (true) isrow Determine si la entrada es un vector de fila
false Matriz lógica 0 (false) iscolumn Determine si la entrada es un vector de columna
eye Matriz identidad isempty Determine si la matriz está vacía
diag obtiene elementos de la diagonal de una matriz Crear y combinar matrices
blkdiag Bloque de matriz diagonal
linspace Generar vectores linealmente espaciados
cat Concatenar matrices
logspace Generar vectores espaciados logarítmicamente
horzcat Concatenar matrices horizontalmente
freqspace Espaciado de frecuencia para respuesta de frecuencia
vertcat Concatenar matrices verticalmente
meshgrid 2-D and 3-D grids
repelem Repita copias de elementos de matriz
ndgrid Grid rectangular en espacio N-D
repmat Repetir copias de matrices
 1. Fundamentos del lenguaje : Matrices y Arreglos

Crear y combinar matrices Indexación

sort Ordena elementos de una matriz colon Creación de vectores, subíndices de matrices e iteración de for-loop
sortrows Ordenar filas de matriz o tabla end Termine el bloque de código o indique el último índice de matriz
flip Voltear el orden de los elementos ind2sub Subíndices del índice lineal
fliplr Flip matriz de izquierda a derecha sub2ind Convertir sub indices a indices lineales
flipud Voltear la matriz de arriba a abajo
rot90 Voltear la matriz de 90°
transpose Transponer un vector o una matriz, no afecta signo
ctranspose Transposición de conjugado complejo, afecta el signo
circshift Desplazar matriz circularmente
shiftdim Cambiar las dimensiones de la matriz

reshape Reformular una matriz

squeeze Eliminar dimensiones de longitud 1
 1. Fundamentos del lenguaje : Matrices y Arreglos

ejemplos

X = zeros(4) T = true(4,4)

X =
T =
0 0 0 0
4×4 logical array
0 0 0 0
0 0 0 0
1 1 1 1
0 0 0 0
1 1 1 1
1 1 1 1
1 1 1 1
X=ones(3,5)

T = false(4,4)
X =

1 1 1 1 1 T =
1 1 1 1 1
1 1 1 1 1 4×4 logical array

0 0 0 0
X = rand(3,5) 0 0 0 0
0 0 0 0
0 0 0 0
X =
E = eye(4,4)
0.1062 0.4897 0.9203 0.2691 0.9427
0.3724 0.3395 0.0527 0.4228 0.4177
0.1981 0.9516 0.7379 0.5479 0.9831 E =

1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
 1. Fundamentos del lenguaje : Matrices y Arreglos

ejemplos
A1 = ones(2,2);
X = rand(4,4)
A2 = 2*ones(3,2);
Diag(X)
A3 = 3*ones(2,3);
X = ans = B = blkdiag(A1,A2,A3)
B =
0.4607 0.6448 0.4820 0.3846 0.4607
0.9816 0.3763 0.1206 0.5830 0.3763 1 1 0 0 0 0 0
0.1564 0.1909 0.5895 0.2518 0.5895 1 1 0 0 0 0 0
0.8555 0.4283 0.2262 0.2904 0.2904 0 0 2 2 0 0 0
0 0 2 2 0 0 0
v = [2 1 -1 -2 -5]; 0 0 2 2 0 0 0
D = diag(v); 0 0 0 0 3 3 3
0 0 0 0 3 3 3

D = A=[1 2;3 4]
B=[5 6; 7 8]
2 0 0 0 0 cat(1,A,B)
0 1 0 0 0 cat(2,A,B)
0 0 -1 0 0
0 0 0 -2 0
0 0 0 0 -5 >> A=[1 2;3 4] >> cat(1,A,B)

A = ans =
D1 = diag(v,1)
1 2 1 2
3 4 3 4
D1 = 5 6
>> B=[5 6; 7 8] 7 8
0 2 0 0 0 0
0 0 1 0 0 0 B = >> cat(2,A,B)
0 0 0 -1 0 0
0 0 0 0 -2 0 5 6 ans =
0 0 0 0 0 -5 7 8
0 0 0 0 0 0 1 2 5 6
3 4 7 8
 1. Fundamentos del lenguaje : Matrices y Arreglos

ejemplos
A=rand(2,2); A=rand(3,5);
repmat(A,3,2); numel(A)

A = ans = A = ans =

0.6171 0.8244 0.6171 0.8244 0.6171 0.8244 0.8419 0.6135 0.8699 0.1192 0.4795 15
0.2653 0.9827 0.2653 0.9827 0.2653 0.9827 0.8329 0.5822 0.2648 0.9398 0.6393
0.6171 0.8244 0.6171 0.8244 0.2564 0.5407 0.3181 0.6456 0.5447
0.2653 0.9827 0.2653 0.9827
0.6171 0.8244 0.6171 0.8244
0.2653 0.9827 0.2653 0.9827 A=rand(3,5);
numel(A)
A=rand(2,5);
length(A) A = ans =
Size(A)
0.8419 0.6135 0.8699 0.1192 0.4795 15
ans = ans = 0.8329 0.5822 0.2648 0.9398 0.6393
0.2564 0.5407 0.3181 0.6456 0.5447
5 2 5
B=[1 2 3 4];
B=rand(2,2,2); issorted(B)
ndims(B);
ans =
>> B=rand(2,2,2)
ans =
logical
B(:,:,1) =
3
1
0.6073 0.4587
0.4501 0.6619

B(:,:,2) =

0.7703 0.6620
0.3502 0.4162
 1. Fundamentos del lenguaje : Matrices y Arreglos

ejemplos
A=[1 2 3 4 5];
C=[1 2 3 4; 5 3 6 8; 9 8 7 6];
isrow(A)
issortedrows(C,1)
iscolumn(A)
A = ans = isempty(A)
A =
0.6171 0.8244 0.6171 0.8244 0.6171 0.8244
0.2653 0.9827 0.2653 0.9827 0.2653 0.9827 1 2 3 4 5
0.6171 0.8244 0.6171 0.8244
0.2653 0.9827 0.2653 0.9827 >> isrow(A) >> iscolumn(A)
0.6171 0.8244 0.6171 0.8244
0.2653 0.9827 0.2653 0.9827 ans = ans =

A=[1 2 3 4 5]; logical logical

isvector(A)
1 0
ans =
>> isempty(A)
logical
ans =
1
logical
A=rand(2,2,2);
ismatrix(A) 0

>> A=rand(2,2,2)
ismatrix(A)
A(:,:,1) =
ans =
0.8217 0.8878
0.4299 0.3912 logical

0
A(:,:,2) =

0.7691 0.8085
0.3968 0.7551
 1. Fundamentos del lenguaje : Matrices y Arreglos

ejemplos
linspace(10,20,5);
surf(X,Y,Z)

ans =

10.0000 12.5000 15.0000 17.5000 20.0000

x = 1:3;
y = 1:5;
[X,Y] = meshgrid(x,y)

x = y =

1 2 3 1 2 3 4 5

X = Y =

1 2 3 1 1 1
1 2 3 2 2 2
1 2 3 3 3 3
1 2 3 4 4 4
1 2 3 5 5 5

Z=X.^2 + Y.^2

Z =

2 5 10
5 8 13
10 13 18
17 20 25
26 29 34
 1. Fundamentos del lenguaje : Matrices y Arreglos

Indexación lineal de matrices Indexación bidimensional de matrices

𝑎1,1 𝑎1,2 𝑎1,3 𝑎1,4 𝑎1,5 𝑎1,𝑛 𝑎1,1 𝑎1,2 𝑎1,3 𝑎1,4 𝑎1,5 𝑎1,𝑛
𝑎2,1 𝑎2,2 𝑎2,3 𝑎2,4 𝑎2,5 𝑎2,𝑛 𝑎2,1 𝑎2,2 𝑎2,3 𝑎2,4 𝑎2,5 𝑎2,𝑛
𝑎3,1 𝑎3,2 𝑎3,3 𝑎3,4 𝑎3,5 ⋯ 𝑎3,𝑛 𝑎3,1 𝑎3,2 𝑎3,3 𝑎3,4 𝑎3,5 ⋯ 𝑎3,𝑛
𝐴= 𝑎4,1 𝑎4,2 𝑎4,3 𝑎4,4 𝑎4,5 𝑎4,𝑛 𝐴= 𝑎4,1 𝑎4,2 𝑎4,3 𝑎4,4 𝑎4,5 𝑎4,𝑛
𝑎5,1 𝑎5,2 𝑎5,3 𝑎5,4 𝑎5,5 𝑎5,𝑛 𝑎5,1 𝑎5,2 𝑎5,3 𝑎5,4 𝑎5,5 𝑎5,𝑛
⋮ ⋱ ⋮ ⋮ ⋱ ⋮
𝑎𝑚,1 𝑎𝑚,2 𝑎𝑚,3 𝑎𝑚,4 𝑎𝑚,5 ⋯ 𝑎𝑚,𝑛 𝑎𝑚,1 𝑎𝑚,2 𝑎𝑚,3 𝑎𝑚,4 𝑎𝑚,5 ⋯ 𝑎𝑚,𝑛

𝐴(2: 3,1: 4) 𝐴(5: 𝑒𝑛𝑑, 5: 𝑒𝑛𝑑)

𝐴(1: 𝑘)
𝑎5,5 ⋯ 𝑎5,𝑛
𝐴 = 𝑎1,1 𝑎2,1 𝑎3,1 𝑎4,1 𝑎5,1 … 𝑎1,2 𝑎2,2 𝑎3,2 𝑎1,2 𝑎1,3 𝑎1,4
𝑎2,2 𝑎2,3 𝑎2,4 𝐴= ⋮ ⋱ ⋮
𝐴= 𝑎 𝑎3,3 𝑎3,4 𝑎𝑚,5 ⋯ 𝑎𝑚,𝑛
3,2
𝑎4,2 𝑎4,3 𝑎4,4
𝐴([2,3,5], 3,5 )
𝑎2,3 𝑎2,5
𝐴 = 𝑎3,3 𝑎3,5
𝑎5,3 𝑎5,5
 1. Fundamentos del lenguaje: Matrices y Arreglos (Operadores fundamentales)

Operadores Aritméticos

Tipo Operador Descripción

Operación
Matriz Arreglo Retorna 1 lógico (true) en caso sean verdaderos ambos
&
Adición + + elementos, y 0 lógico (false) en caso contrario
Sustracción - - Retorna 0 lógico (false) en caso sean falsos ambos
|
elementos, y 1 lógico (true) en caso contrario
Multiplicación * .*
~ Complementa cada elemento del arreglo
División Izquierda \ .\
Retorna 1 (lógico) en caso sean verdaderos un
División Derecha / ./ elemento y falso el otro elemento cuyas posiciones en
xor
Exponenciación ^ .^ los arreglos sea la misma; en caso contrario retorna 0
lógico (false).
Operadores Relacionales
Operador Descripción
< Menor que
> Mayor que
<= Menor o igual que
>= Mayor o igual que
== Igual a
~= Diferente de
 1. Fundamentos del lenguaje : Matrices y Arreglos

Ejemplo:
Aplicación 01: Corrientes de secuencia Corrientes de falla monofásica, fase A, (5 ohm)
%corrientes de sacuencia +-0
Ia=1167*cosd(-7.8)+j*1167*sind(-7.8);
Ib=106*cosd(-129.3)+j*106*sind(-129.3);
Ic=106*cosd(108.2)+j*106*sind(108.2);
In=Ia+Ib+Ic;
Corrientes prefalla Iabc=[Ia;Ib;Ic];
a=(-1/2+j*sqrt(3)/2);
%corrientes de secuencia +-0 A=[1 1 1;1 a^2 a;1 a a^2];
Ia=107*cosd(-10.6)+j*107*sind(-10.6); I012=A^(-1)*(Iabc);
Ib=107*cosd(-130.6)+j*107*sind(-130.6);
Ic=107*cosd(109.3)+j*107*sind(109.3); >> Iabc >> In
In=Ia+Ib+Ic; Iabc =
In =
Iabc=[Ia;Ib;Ic];
1.0e+03 *
a=(-1/2+j*sqrt(3)/2);
1.0560e+03 - 1.3971e+02i
A=[1 1 1;1 a^2 a;1 a a^2]; 1.1562 - 0.1584i
I012=A^(-1)*(Iabc); -0.0671 - 0.0820i
>> Iabc >> In -0.0331 + 0.1007i
Iabc =
In = >> I012
1.0e+02 * I012 =
0.1762 + 0.0619i
1.0517 - 0.1968i 1.0e+02 *
-0.6963 - 0.8124i
-0.3537 + 1.0099i 3.5199 - 0.4657i
4.5486 - 0.6573i
>> I012 3.4936 - 0.4608i
I012 =

1.0e+02 *

0.0006 + 0.0002i
1.0516 - 0.1974i
-0.0005 + 0.0004i
 1. Fundamentos del lenguaje : Matrices y Arreglos
Flujo de potencia

Aplicación 02: Datos de barras y de líneas

%flujo de potencia
clear;clc; 1 2
%datos de barras---------------------------------------------
% b,Pg,Qg,Pc,Qc,V,delta,tipo Barra: 1.slack 2.carga 3.generador
D=[1 0.00 0 0.5 0.3099 1.00 0 1;
2 0.00 0 1.7 1.0535 1.00 0 2;
3 0.00 0 2.0 1.2394 1.00 0 2;
4 3.18 0 0.8 0.4958 1.02 0 3];
%extraer datos-----------------------------------------------
PG=D(:,2); %potencia activa generada
3 4
QG=D(:,3); %potencia reactiva generada
PC=D(:,4); %Potencia activa consuminda
QC=D(:,5); %potecia reactiva consumida
V=D(:,6); %tensión de barra
ang=D(:,7); %ángulo de barra
%datos de línea---------------------------------------------- Barra Pg(p.u) Qg(p.u.) Pd(p.u) Qd(p.u) Tensión(p.u) Angulo(°) Tipo
L=[1 2 0.01008+j*0.05040 0.05125; 1 - - 0.5 0.3099 1 0 Slack
1 3 0.00744+j*0.03720 0.03875;
2 4 0.00744+j*0.03720 0.03875; 2 0 0 1.7 1.0535 - - Carga
3 4 0.01272+j*0.06360 0.06375]; 3 0 0 2.0 1.2394 - - Carga
%nodos de conexión-------------------------------------------
de=L(:,1); 4 3.18 - 0.8 0.4958 1.02 - Generador
aa=L(:,2);
Va=0;%tensión inicial de comparación del error Línea Nodos X(p.u) R(p.u) Ysh/2 (p.u)
L1 1–2 0.01008 0.05040 0.05125
L2 1–3 0.00744 0.03720 0.03875
L3 2–4 0.00744 0.03720 0.03875
L4 3–4 0.01272 0.06360 0.06375
 1. Fundamentos del lenguaje: Tipos de datos

Tipos de
datos

Manipulador Contenedor
Booleano Numérico texto
de Función Heterogéneo

Logico char
function_handle
(1 byte) (2 byte)

Punto struct Cell

Entero estructura Tipo celdas
flotante

Simple precisión Doble precisión Con signo Sin signo

single double (default) int8 uint8
4 bytes 8 bytes int16 uint16
int32 uint32
int64 uint64
 1. Fundamentos del lenguaje : Matrices y Arreglos

ejemplos
A= 1234;
B=single(A); A={1234,'hola mundo',datetime('30/08/2020')}
whos
Name Size Bytes Class Attributes A =

A 1x1 8 double 1×3 cell array

B 1x1 4 single
{[1234]} {'hola mundo'} {[30-Aug-2020]}
C=1234.56;
D=int8(C)
whos whos
Name Size Bytes Class Attributes
Name Size Bytes Class Attributes
A 1x3 373 cell
C 1x1 8 double
D 1x1 1 int8
y = 7;
fh= @(x)x.^2+y;
A='holamundo'
z = fh(2)
whos
whos
Name Size Bytes Class Attributes
Name Size Bytes Class Attributes
A 1x9 18 char
fh 1x1 32 function_handle
y = 7; y 1x1 8 double
fh= @(x)x.^2+y; z 1x1 8 double
z = fh(2)
whos
Name Size Bytes Class Attributes

fh 1x1 32 function_handle
y 1x1 8 double
z 1x1 8 double
 1. Fundamentos del lenguaje: Bucles y declaraciones condicionales
Sentencias de Control Selectivas Simple: if … else

if condición if condición
sentencia(s)1
else else
sentencia(s)2 sentencia(s)2
end end

x = 10;
minVal = 2;
maxVal = 6;

if (x >= minVal) && (x <= maxVal)

disp('dentro del rango.')
elseif (x > maxVal)
if condición disp('excede valor maximo.')
sentencia(s)1 else
else disp('menor al valor mínimo')
end
End
excede valor máximo.
 1. Fundamentos del lenguaje: Bucles y declaraciones condicionales
Sentencias de Control Selectivas Multiple: if … elseif...else Ejemplo: Datos de entrada

línea corta línea media

if cond. 1
sentencia. 1
elseif cond. 2 Resultado línea corta
sentencia. 2
:
elseif cond. N
sentencia. N
else Resultado línea media
sent. por defecto
end
 1. Fundamentos del lenguaje: Bucles y declaraciones condicionales

%tipo de linea >> A %tipo de línea >> A

% corta = 1 < 80 km % corta = 1 < 80 km
% media = 2 > 80 km & <240km A = % media = 2 > 80 km & <240km A =
Lon = 30; Lon = 100;
tipo = 1; 1 tipo = 2; 1.0223 + 0.0079i
R20 = 1.32; R20 = 1.32;
DMG = 4849.95; >> B DMG = 4849.95; >> B
D = 6.35; D=6.35;
r = D/2; B = r=D/2; B =
f = 60; f=60;
rmg=r*exp(1)^(-1/4); 48.3823 +17.1488i rmg=r*exp(1)^(-1/4); 1.6127e+02 + 5.7163e+01i
R75=(75+228)/(20+228)*R20; R75=(75+228)/(20+228)*R20;
C=2*pi*8.85*1e-9./log(DMG./rmg); >> C C=2*pi*8.85*1e-9./log(DMG./rmg); >> C
Y=2*pi*f*C; Y=2*pi*f*C;
L=(2*log(DMG./rmg))*1e-4; C = L=(2*log(DMG./rmg))*1e-4; C =
X=2*pi*f*L; X=2*pi*f*L;
Z=R75+j*X; 0 Z=R75+j*X; 2.7959e-04 + 1.0926e-06i
Yk=Y*Lon; Yk=Y.*Lon;
Xk=X*Lon; >> D Xk=X.*Lon; >> D
Zk=Z*Lon; Zk=Z.*Lon;
if tipo ==1 D = if tipo==1 %linea corta D =
A=1; A=1;
B=Zk; 1 B=Zk; 1.0223 + 0.0079i
C=0; C=0;
D=1; D=1;
else elseif tipo==2%linea media
disp('no es línea corta'); A=1+(Yk*Zk)/2;
end B=Zk;
C=Yk*(1+Yk*Zk/4);
D=A;
else
disp('no es línea corta ni media');
end
 1. Fundamentos del lenguaje: Bucles y declaraciones condicionales
Sentencias de Control Selectivas Múltiples: switch ... case ... otherwise

switch var conductor = 'AAAC';

case CTE_1 switch conductor
sent. 1 case 'SWAN'
case CTE_2 disp('SWAN');
sent. 2 D=[6.350 1.32];
: case 'SPARROW'
case CTE_N disp('SPARROW');
sent. N D=[8.026 0.83];
otherwise case 'ROBIN'
sent. por defecto disp('ROBIN');
end D=[9.017 0.658];
case 'RAVEN'
disp('RAVEN');
D=[10.109 0.5220];
case 'QUAIL'
disp('QUAIL');
D=[11.354 0.414];
otherwise
disp('no se encuentra el conductor');
end
 1. Fundamentos del lenguaje: Bucles y declaraciones condicionales
Sentencias de Control Iterativa: while % corta = 1 < 80 km, media = 2 > 80 km & <240km
Lon = 30; Lon =
while Lon < 100
tipo = 1; 40
R20 = 1.32;
DMG = 4849.95;
D=6.35; Lon =
r=D/2;
f=60; 50
rmg=r*exp(1)^(-1/4);
R75=(75+228)/(20+228)*R20;
C=2*pi*8.85*1e-9./log(DMG./rmg); Lon =
Y=2*pi*f*C;
L=(2*log(DMG./rmg))*1e-4; 60
X=2*pi*f*L;
Z=R75+j*X;
Yk=Y.*Lon; Lon =
Xk=X.*Lon;
Zk=Z.*Lon; 70
if tipo==1 %linea corta
A=1;
while condición Lon =
B=Zk;
sentencia(s)
C=0;
end 80
D=1;
elseif tipo==2%linea media
A=1+(Yk*Zk)/2;
B=Zk; Lon =
C=Yk*(1+Yk*Zk/4);
D=A; 90
else
disp('no es línea corta ni media');
end Lon =
Lon = Lon+10
end 100
 1. Fundamentos del lenguaje: Bucles y declaraciones condicionales
Sentencias de Control Iterativa: for

for rango(k)
sentencia(s)
end

𝑛
𝜕𝑃𝑖
= ෍ 𝑉𝑖 . 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . sin 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘
𝜕𝛿𝑖
𝑘=1

clc;clear;
Ybus=[8.9851 -44.8359i,-3.8156 + 19.0781i,-5.1695 + 25.8478i,0.00000 + 0.0000i;
-3.8156 + 19.0781i,8.9851 - 44.8359i,0.0000 + 0.0000i,-5.1695 + 25.8478i;
-5.1695 + 25.8478i,0.0000 + 0.0000i,8.1932 - 40.8638i,-3.0237 + 15.1185i;
0.00000 + 0.0000i,-5.1695 + 25.8478i,-3.0237 + 15.118i,8.1932 - 40.8638i];

V =[1.0000;1.0000;1.0000;1.0200];
ang=[0 0 0 0];
i=1;
SJ11=0;
mg=[2 3 4 2 3];

for k=1:4 %para cada una de las barras

if mg(i)~=k %si i~=k %mg = [2 3 4 2 3]
SJ11=SJ11+abs(V(mg(i)))*abs(V(k))*abs(Ybus(mg(i),k))*sin(angle(Ybus(mg(i),k))-ang(mg(i))+ang(k));
end
end
J(i,1)=SJ11;
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon
Flujo de potencia

%flujo de potencia
clear;clc; 1 2
%datos de barras---------------------------------------------
% b,Pg,Qg,Pc,Qc,V,delta,tipo Barra: 1.slack 2.carga 3.generador
D=[1 0.00 0 0.5 0.3099 1.00 0 1;
2 0.00 0 1.7 1.0535 1.00 0 2;
3 0.00 0 2.0 1.2394 1.00 0 2;
4 3.18 0 0.8 0.4958 1.02 0 3];
%extraer datos-----------------------------------------------
PG=D(:,2); %potencia activa generada
3 4
QG=D(:,3); %potencia reactiva generada
PC=D(:,4); %Potencia activa consuminda
QC=D(:,5); %potecia reactiva consumida
V=D(:,6); %tensión de barra
ang=D(:,7); %ángulo de barra
%datos de línea---------------------------------------------- Barra Pg(p.u) Qg(p.u.) Pd(p.u) Qd(p.u) Tensión(p.u) Angulo(°) Tipo
L=[1 2 0.01008+j*0.05040 0.05125; 1 - - 0.5 0.3099 1 0 Slack
1 3 0.00744+j*0.03720 0.03875;
2 4 0.00744+j*0.03720 0.03875; 2 0 0 1.7 1.0535 - - Carga
3 4 0.01272+j*0.06360 0.06375]; 3 0 0 2.0 1.2394 - - Carga
%nodos de conexión------------------------------------------
de=L(:,1); 4 3.18 - 0.8 0.4958 1.02 - Generador
aa=L(:,2);
Va=0;%tensión inicial de comparación del error Línea Nodos X(p.u) R(p.u) Ysh/2 (p.u)
K>> de L1 1–2 0.01008 0.05040 0.05125
de =
L2 1–3 0.00744 0.03720 0.03875
1 L3 2–4 0.00744 0.03720 0.03875
1
2 L4 3–4 0.01272 0.06360 0.06375
3
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon

Matriz de admitancías

%formación del ybus diagonal---------------------------------------- 𝒚𝟏𝟏 𝑦12 𝑦13 𝑦14

Ybus=zeros(length(D(:,1)),length(L(:,1)));
𝑦 𝒚𝟐𝟐 𝑦23 𝑦24
for k=1:length(D(:,1)) 𝑌𝑏𝑢𝑠 = 𝑦21 𝑦32 𝒚𝟑𝟏 𝑦34
for p=1:length(L(:,1)) 31
if de(p)==k
Ybus(k,k)=Ybus(k,k)+1./L(p,3)+j*L(p,4);
𝑦41 𝑦42 𝑦43 𝒚𝟒𝟒
elseif aa(p)==k
Ybus(k,k)=Ybus(k,k)+1./L(p,3)+j*L(p,4); Valores de la diagonal
end
end
𝑖𝑖 1
end 𝑌𝑏𝑢𝑠 = + 𝑗 ∗ 𝑌𝑠ℎ𝑢𝑛𝑡
%valores fuera de la diagonal--------------------------------------- 𝑅𝑖𝑖 + 𝑗. 𝑋𝑖𝑖
for k=1:length(L(:,1))
Ybus(L(k,1),L(k,2))=-1./L(k,3);%encima de la diagonal
Valores fuera de la diagonal
Ybus(L(k,2),L(k,1))=-1./L(k,3);%debajo de la diagonal
Y(L(k,1),L(k,2))=1./L(k,3)*10;%admitancia encima de la diagonal
𝑖𝑗 1 𝑗𝑖 1
Y(L(k,2),L(k,1))=1./L(k,3)*10;%admitancia debajo de la diagonal 𝑌𝑏𝑢𝑠 = − 𝑌𝑏𝑢𝑠 = −
Bc(L(k,1),L(k,2))=L(k,4)*10;%susceptancia encima de la diagonal 𝑅𝑖𝑖 + 𝑗. 𝑋𝑖𝑖 𝑅𝑖𝑖 + 𝑗. 𝑋𝑖𝑖
Bc(L(k,2),L(k,1))=L(k,4)*10;%susceptancia debajo de la diagonal
end
%------------------------------------------------------------------ 𝑖𝑗 1 𝑗𝑖 1
𝑦𝑙 = 𝑦𝑙 =
𝑅𝑖𝑖 + 𝑗. 𝑋𝑖𝑖 𝑅𝑖𝑖 + 𝑗. 𝑋𝑖𝑖

𝑖𝑗 1
𝐵𝑐 =
𝑋𝑖𝑖
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon

SJ11 SJ22

%matriz Jacobiana H L
cp=0; %cte barra carga
cq=0; %cte barra carga DPQ 𝜕𝑃2 𝜕𝑃2 𝜕𝑃2 𝜕𝑃2 𝜕𝑃2
cg=0;
for k=1:length(D(:,1)) %longitud:4 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 𝜕𝑉2 𝜕𝑉3
if D(k,8)==1 %slack 𝜕𝑃3 𝜕𝑃3 𝜕𝑃3 𝜕𝑃3 𝜕𝑃3
sl=k;
elseif D(k,8)==2 %PQ ∆𝑃2 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 𝜕 𝑉 2 𝜕 𝑉 3 ∆𝛿2
cp=cp+1; ∆𝑃3 ∆𝛿3
cq=cq+1; 𝜕𝑃4 𝜕𝑃4 𝜕𝑃4 𝜕𝑃4 𝜕𝑃4
dp(cp)=k; ∆𝑃4 = . ∆𝛿4
dq(cq)=k;
∆𝑄2 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 𝜕𝑉2 𝜕𝑉3
elseif D(k,8)==3 %generación
∆𝑉2
cp=cp+1; ∆𝑄3 𝜕𝑄2 𝜕𝑄2 𝜕𝑄2 𝜕𝑄2 𝜕𝑄2 ∆𝑉3
cg=cg+1;
dp(cp)=k;
𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 𝜕𝑉2 𝜕𝑉3
dg(cg)=k; 𝜕𝑄3 𝜕𝑄3 𝜕𝑄3 𝜕𝑄3 𝜕𝑄3
end
end 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 𝜕𝑉2 𝜕𝑉3
J=zeros(cp+cq);%matriz jacobiana inicial----------------------------
mg=[dp dq];%subindice de columna de la matiz jacobiana--------------
SJ33 M V SJ44
DV=[ang(dp);V(dq)];%matriz de tensiones inicial---------------------
K>> J K>> DV
mg = [2 3 4 2 3]
J = DV =
0
0
0
0
0
0
0
0
0
0 0 ∆𝑃𝑖 = (𝑃𝑖𝐺𝑒𝑛 − 𝑃𝑖𝐶𝑜𝑛 ) − 𝑃𝑖𝑐𝑎𝑙
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 1 ∆𝑄𝑖 = (𝑄𝑖𝐺𝑒𝑛 −𝑄𝑖𝐶𝑜𝑛 ) − 𝑄𝑖𝑐𝑎𝑙
1
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon
for pk=1:20
J=zeros(cp+cq);
SJ11=0;
SJ22=0;
SJ33=0;
SJ44=0;
SP=0;
for i=1:length(J(:,1))% filas
for p=1:length(J(:,1)) %columnas

%matriz 1
if p<=length(dp) & i<=length(dp)
if mg(i)==mg(p)
for k=1:length(D(:,1)) %para cada una de las barras
if mg(i)~=k %mg = [2 3 4 2 3]
SJ11=SJ11+abs(V(mg(i)))*abs(V(k))*abs(Ybus(mg(i),k))*sin(angle(Ybus(mg(i),k))-ang(mg(i))+ang(k));
SP=SP+abs(V(mg(i)))*abs(V(k))*abs(Ybus(mg(i),k))*cos(angle(Ybus(mg(i),k))-ang(mg(i))+ang(k));
end
end
J(i,p)=SJ11;
PQcal(i)=SP+abs(V(mg(i)))^2*real(Ybus(mg(i),mg(p)));
%Pi = Vm(n)^2*Ym(n,n)*cos(t(n,n))+J33;
DPQ(i,1)=PG(mg(i))-PC(mg(i))-PQcal(i);
SJ11=0;
SP=0;
else
J(i,p)=-abs(V(mg(i)))*abs(V(mg(p)))*abs(Ybus(mg(i),mg(p)))*sin(angle(Ybus(mg(i),mg(p)))-ang(mg(i))+ang(mg(p)));
end
𝑛 𝑛
𝜕𝑃𝑖 𝜕𝑃2 𝜕𝑃2 𝜕𝑃2
= ෍ 𝑉𝑖 . 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . sin 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 𝑃𝑖𝑐𝑎𝑙 = 𝑉 2𝑖 . 𝐺𝑖𝑖 + ෍ 𝑉𝑖 . 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . cos 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘
𝜕𝛿𝑖
𝑘=1 𝜕𝑃3 𝑘=1
𝜕𝑃3 𝜕𝑃3
𝜕𝑃𝑖 𝐻=
= − 𝑉𝑖 . 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . sin 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 ∆𝑃𝑖 = (𝑃𝑖𝐺𝑒𝑛 − 𝑃𝑖𝐶𝑜𝑛 ) − 𝑃𝑖𝑐𝑎𝑙
𝜕𝛿𝑘
𝜕𝑃4 𝜕𝑃4 𝜕𝑃4
𝜕𝛿2 𝜕𝛿3 𝜕𝛿4
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon

%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%matriz 2
elseif p>length(dp) & i<=length(dp)
if mg(i)==mg(p)
for k=1:length(D(:,1))
if mg(i)~=k
SJ22=SJ22+abs(V(k))*abs(Ybus(mg(i),k))*cos(angle(Ybus(mg(i),k))-ang(mg(i))+ang(k));
end
end
J(i,p)=SJ22+2*abs(V(mg(i)))*real(Ybus(mg(i),mg(p)));
SJ22=0;
else
J(i,p)=abs(V(mg(i)))*abs(Ybus(mg(i),mg(p)))*cos(angle(Ybus(mg(i),mg(p)))-ang(mg(i))+ang(mg(p)));
end

𝑛
𝜕𝑃𝑖
= 2. 𝑉𝑖 . 𝐺𝑖𝑖 + ෍ 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . 𝑐𝑜𝑠 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝜕𝑃2 𝜕𝑃2
𝜕𝑉𝑖
𝑘=1
𝜕𝑉2 𝜕𝑉3
𝜕𝑃𝑖 𝜕𝑃3 𝜕𝑃3
= 𝑉𝑖 . 𝑌𝑖𝑘𝑏𝑢𝑠 . 𝑐𝑜𝑠 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝐿=
𝜕𝑉𝑘 𝜕𝑉2 𝜕𝑉3
𝜕𝑃4 𝜕𝑃4
𝜕𝑉2 𝜕𝑉3
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon

Aplicación: Flujo de potencia método de Newton Rapshon

%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
elseif p<=length(dp) & i>length(dp)
if mg(i)==mg(p)
for k=1:length(D(:,1))
if mg(i)~=k
SJ33=SJ33-abs(V(mg(i)))*abs(V(k))*abs(Ybus(mg(i),k))*cos(angle(Ybus(mg(i),k))-ang(mg(i))+ang(k));
SP=SP+abs(V(mg(i)))*abs(V(k))*abs(Ybus(mg(i),k))*sin(angle(Ybus(mg(i),k))-ang(mg(i))+ang(k));
end
end
J(i,p)=-SJ33;
PQcal(i)=-SP-abs(V(mg(i)))^2*imag(Ybus(mg(i),mg(p)));
%ki = -Vm(n)^2*Ym(n,n)*sin(t(n,n))-J11;
DPQ(i,1)=QG(mg(i))-QC(mg(i))-PQcal(i);
SJ33=0;
SP=0;
else
J(i,p)=-abs(V(mg(i)))*abs(V(mg(p)))*abs(Ybus(mg(i),mg(p)))*cos(angle(Ybus(mg(i),mg(p)))-ang(mg(i))+ang(mg(p)));
end

𝑛 𝑛
𝜕𝑄𝑖
= ෍ 𝑉𝑖 . 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . cos 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝜕𝑄2 𝜕𝑄2 𝜕𝑄2 𝑄𝑖𝑐𝑎𝑙 = 𝑉 2
𝑖 . 𝐵𝑖𝑖 − ෍ 𝑉𝑖 . 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . sin 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘
𝜕𝛿𝑖
𝑘=1 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 𝑘=1
𝑀=
𝜕𝑄𝑖 𝜕𝑄3 𝜕𝑄3 𝜕𝑄3
= − 𝑉𝑖 . 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . cos 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝜕𝛿2 𝜕𝛿3 𝜕𝛿4 ∆𝑄𝑖 = (𝑄𝑖𝐺𝑒𝑛 −𝑄𝑖𝐶𝑜𝑛 ) − 𝑄𝑖𝑐𝑎𝑙
𝜕𝛿𝑘
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon

%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%matriz 4
elseif p>length(dp) & i>length(dp)
if mg(i)==mg(p)
for k=1:length(D(:,1))
if mg(i)~=k
SJ44=SJ44+abs(V(k))*abs(Ybus(mg(i),k))*sin(angle(Ybus(mg(i),k))-ang(mg(i))+ang(k));
end
end
J(i,p)=-SJ44-2*abs(V(mg(i)))*imag(Ybus(mg(i),mg(p)));
SJ44=0;
else
J(i,p)=-abs(V(mg(i)))*abs(Ybus(mg(i),mg(p)))*sin(angle(Ybus(mg(i),mg(p)))-ang(mg(i))+ang(mg(p)));
end
end
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
end
end

𝑛
𝜕𝑄𝑖
= −2. 𝑉𝑖 . 𝐵𝑖𝑖 + ෍ 𝑉𝑘 . 𝑌𝑖𝑘𝑏𝑢𝑠 . 𝑠𝑖𝑛 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝜕𝑃2 𝜕𝑃2
𝜕𝑉𝑖
𝑘=1
𝜕𝑉2 𝜕𝑉3
𝜕𝑄𝑖 𝜕𝑃3 𝜕𝑃3
= − 𝑉𝑖 . 𝑌𝑖𝑘𝑏𝑢𝑠 . 𝑠𝑖𝑛 𝜃𝑖𝑘 − 𝜕𝑖 + 𝜕𝑘 , 𝑖 ≠ 𝑘 𝑉=
𝜕𝑉𝑘 𝜕𝑉2 𝜕𝑉3
𝜕𝑃4 𝜕𝑃4
𝜕𝑉2 𝜕𝑉3
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon

VT=inv(J)*DPQ;
DV=DV+VT;
VNa(dp,1)=cos(DV(1:length(dp)))+j*sin(DV(1:length(dp)));
VNa(sl,1)=cos(ang(sl))+j*sin(ang(sl));
VNV(dq,1)=abs(DV(length(dp)+1:end));
VNV(sl,1)=abs(V(sl));
VNV(dg,1)=abs(V(dg));
V=VNV.*VNa;
ang=angle(V);
if abs(V-Va)<0.0001
break;
else
Va=V;
cumple con la tolerancia??
end
end
 1. Fundamentos del lenguaje: Flujo de potencia por el método newton Rapshon
tension = angulo =
Aplicación: Flujo de potencia método de Newton Rapshon
1.0000 0
0.9824 -0.9761
%flujo de potencia---------------------------------------------------------
0.9690 -1.8722
cont=1;
1.0200 1.5231
for k=1:length(D(:,1))
for p=1:length(L(:,1)) jacobiano =
if k~=p
I(k) =(V(k) - V(p))*Y(k,p)/10 + j*Bc(k,p)*V(k)/10; 44.3270 0 -25.6508 7.0969 0
S(k,p)=V(k)*conj(I(k))*100; 0 39.6096 -14.7398 0 5.8755
P(cont,:)=[k p real(S(k,p))]; -26.1026 -15.0938 41.1963 -4.1183 -2.1655
Q(cont,:)=[k p imag(S(k,p))]; -10.3721 0 6.3048 42.9755 0
cont=cont+1; 0 -9.6932 3.8683 0 38.3186
end
end Pkp = Qkp =
PT(k,:)=[k sum(real(S(k,:)))];
QT(k,:)=[k sum(imag(S(k,:)))]; 1.0000 2.0000 38.6915 1.0000 2.0000 22.2985
end 1.0000 3.0000 98.1175 1.0000 3.0000 61.2124
1.0000 4.0000 0 1.0000 4.0000 0
%-------------------------------------------------------------------------- 2.0000 1.0000 -38.4648 2.0000 1.0000 -31.2363
jacobiano=J 2.0000 3.0000 0 2.0000 3.0000 0
tension=abs(V) 2.0000 4.0000 -131.5352 2.0000 4.0000 -74.1137
angulo=ang*180/pi 3.0000 1.0000 -97.0861 3.0000 1.0000 -63.5687
Pkp=P 3.0000 2.0000 0 3.0000 2.0000 0
Qkp=Q 3.0000 4.0000 -102.9139 3.0000 4.0000 -60.3713
Ptotal=PT 4.0000 1.0000 0 4.0000 1.0000 0
Qtotal=QT 4.0000 2.0000 133.2507 4.0000 2.0000 74.9196
4.0000 3.0000 104.7493 4.0000 3.0000 56.9301

Ptotal = Qtotal =

1.0000 136.8091 1.0000 83.5108

2.0000 -170.0000 2.0000 -105.3500
3.0000 -200.0000 3.0000 -123.9400
4.0000 238.0000 4.0000 131.8496
1. Fundamentos del lenguaje

¿Preguntas?

Expositor : Albert Huarhua Tupayachi

Correo : ahuarhuaa@gmail.com
Celular : 960932230