/*
* MATLAB Compiler: 3.0
* Date: Wed Jul 06 02:26:26 2005
* Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
* "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
* "array_indexing:on" "-O" "optimize_conditionals:on" "-m" "-W" "main" "-L"
* "C" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-B" "sgl" "-m" "-W" "main"
* "-L" "C" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
* "libmwsglm.mlib" "micamponograf.m" "micampo.m" "matrices1lazo.m"
* "leeActivo.m" "leePasivo.m" "matActivo.m"
*/
#include "matrices.h"
#include "libmatlbm.h"
static mxArray * _mxarray0_;
static mxArray * _mxarray1_;
static mxArray * _mxarray2_;
static mxArray * _mxarray3_;
static mxArray * _mxarray4_;
static mxArray * _mxarray5_;
static mxArray * _mxarray6_;
static mxArray * _mxarray7_;
static mxArray * _mxarray8_;
static mxArray * _mxarray9_;
static mxArray * _mxarray10_;
static mxArray * _mxarray11_;
static mxArray * _mxarray12_;
static mxArray * _mxarray13_;
static mxArray * _mxarray14_;
static mxArray * _mxarray15_;
static mxArray * _mxarray16_;
void InitializeModule_matrices(void) {
_mxarray0_ = mclInitializeDouble(1.0);
_mxarray1_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
_mxarray2_ = mclInitializeDouble(2.0);
_mxarray3_ = mclInitializeDouble(6.0);
_mxarray4_ = mclInitializeDouble(7.0);
_mxarray5_ = mclInitializeDouble(8.0);
_mxarray6_ = mclInitializeDouble(9.0);
_mxarray7_ = mclInitializeDouble(3.0);
_mxarray8_ = mclInitializeDouble(4.0);
_mxarray9_ = mclInitializeDouble(3.141592653589793);
_mxarray10_ = mclInitializeDouble(1e-07);
_mxarray11_ = mclInitializeDouble(0.0);
_mxarray12_ = mclInitializeDouble(-1.0);
_mxarray13_ = mclInitializeComplex(0.0, 6.283185307179586);
_mxarray14_ = mclInitializeComplex(0.0, 1.0);
_mxarray15_ = mclInitializeDouble(6.283185307179586);
_mxarray16_ = mclInitializeDouble(180.0);
}
void TerminateModule_matrices(void) {
mxDestroyArray(_mxarray16_);
mxDestroyArray(_mxarray15_);
mxDestroyArray(_mxarray14_);
mxDestroyArray(_mxarray13_);
mxDestroyArray(_mxarray12_);
mxDestroyArray(_mxarray11_);
mxDestroyArray(_mxarray10_);
mxDestroyArray(_mxarray9_);
mxDestroyArray(_mxarray8_);
mxDestroyArray(_mxarray7_);
mxDestroyArray(_mxarray6_);
mxDestroyArray(_mxarray5_);
mxDestroyArray(_mxarray4_);
mxDestroyArray(_mxarray3_);
mxDestroyArray(_mxarray2_);
mxDestroyArray(_mxarray1_);
mxDestroyArray(_mxarray0_);
}
static mxArray * Mmatrices(mxArray * * mislazos,
int nargout_,
mxArray * f,
mxArray * coordlazos,
mxArray * coordcond);
_mexLocalFunctionTable _local_function_table_matrices
= { 0, (mexFunctionTableEntry *)NULL };
/*
* The function "mlfMatrices" contains the normal interface for the "matrices"
* M-function from file "c:\matlab6p5\work\matrices.m" (lines 1-206). This
* function processes any input arguments and passes them to the implementation
* version of the function, appearing above.
*/
mxArray * mlfMatrices(mxArray * * mislazos,
mxArray * f,
mxArray * coordlazos,
mxArray * coordcond) {
int nargout = 1;
mxArray * Ilazos = NULL;
mxArray * mislazos__ = NULL;
mlfEnterNewContext(1, 3, mislazos, f, coordlazos, coordcond);
if (mislazos != NULL) {
++nargout;
}
Ilazos = Mmatrices(&mislazos__, nargout, f, coordlazos, coordcond);
mlfRestorePreviousContext(1, 3, mislazos, f, coordlazos, coordcond);
if (mislazos != NULL) {
mclCopyOutputArg(mislazos, mislazos__);
} else {
mxDestroyArray(mislazos__);
}
return mlfReturnValue(Ilazos);
}
/*
* The function "mlxMatrices" contains the feval interface for the "matrices"
* M-function from file "c:\matlab6p5\work\matrices.m" (lines 1-206). The feval
* function calls the implementation version of matrices through this function.
* This function processes any input arguments and passes them to the
* implementation version of the function, appearing above.
*/
void mlxMatrices(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
mxArray * mprhs[3];
mxArray * mplhs[2];
int i;
if (nlhs > 2) {
mlfError(
mxCreateString(
"Run-time Error: File: matrices Line: 20 Column:"
" 1 The function \"matrices\" was called with mo"
"re than the declared number of outputs (2)."),
NULL);
}
if (nrhs > 3) {
mlfError(
mxCreateString(
"Run-time Error: File: matrices Line: 20 Column"
": 1 The function \"matrices\" was called with "
"more than the declared number of inputs (3)."),
NULL);
}
for (i = 0; i < 2; ++i) {
mplhs[i] = NULL;
}
for (i = 0; i < 3 && i < nrhs; ++i) {
mprhs[i] = prhs[i];
}
for (; i < 3; ++i) {
mprhs[i] = NULL;
}
mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
mplhs[0] = Mmatrices(&mplhs[1], nlhs, mprhs[0], mprhs[1], mprhs[2]);
mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
plhs[0] = mplhs[0];
for (i = 1; i < 2 && i < nlhs; ++i) {
plhs[i] = mplhs[i];
}
for (; i < 2; ++i) {
mxDestroyArray(mplhs[i]);
}
}
/*
* The function "Mmatrices" is the implementation version of the "matrices"
* M-function from file "c:\matlab6p5\work\matrices.m" (lines 1-206). It
* contains the actual compiled code for that M-function. It is a static
* function and must only be called from one of the interface functions,
* appearing below.
*/
/*
* % Calcula las matrices del problema y devuelve el vector de
* % intensidades de lazos.
* %
* % Sintaxis: function [Ilazos,mislazos]=matrices(f,lazos,fases,Ifases)
* %
* % lazos es una matriz de dimensiones (m,4) donde cada fila representa
* % a un lazo y las columnas son, por este orden:
* %
* % n;x1;y1;x2;y2;x3;y3;x4;y4;R';rgm;Xc1;Xc2;Xc3;1/0;
* %
* % Si el ultimo numero es 1 es porque las xc estan en pu, y si es 0 es que
* % son ohm/m.
* %
* % mislazos es una matriz que contiene los lazos originales
* % descompuestos en lazos simples de dos conductores.
* % Por tanto sera del tipo:
* %
* % 2;x1;y1;x2;y2;I;theta;Xc;1/0;
*
* function [Ilazos,mislazos]=matrices(f,coordlazos,coordcond)
*/
static mxArray * Mmatrices(mxArray * * mislazos,
int nargout_,
mxArray * f,
mxArray * coordlazos,
mxArray * coordcond) {
mexLocalFunctionTable save_local_function_table_
= mclSetCurrentLocalFunctionTable(&_local_function_table_matrices);
mxArray * Ilazos = NULL;
mxArray * ans = NULL;
mxArray * Ip = NULL;
mxArray * y = NULL;
mxArray * Zp = NULL;
mxArray * dI1k = NULL;
mxArray * dI2k = NULL;
mxArray * dI2L2 = NULL;
mxArray * dI1L1 = NULL;
mxArray * dI2L1 = NULL;
mxArray * dI1L2 = NULL;
mxArray * Z = NULL;
mxArray * Xprima = NULL;
mxArray * X = NULL;
mxArray * s = NULL;
mxArray * R = NULL;
mxArray * columna = NULL;
mxArray * fila = NULL;
mxArray * n = NULL;
mxArray * m = NULL;
mxArray * t = NULL;
mxArray * u = NULL;
mxArray * numero = NULL;
mclCopyArray(&f);
mclCopyArray(&coordlazos);
mclCopyArray(&coordcond);
/*
*
* % Convertimos la matriz de lazos que nos pasan a otra de lazos simples.
* numero=1;
*/
mlfAssign(&numero, _mxarray0_);
/*
* for u=1:size(coordlazos,1)
*/
{
int v_ = mclForIntStart(1);
int e_
= mclForIntEnd(
mlfSize(
mclValueVarargout(),
mclVa(coordlazos, "coordlazos"),
_mxarray0_));
if (v_ > e_) {
mlfAssign(&u, _mxarray1_);
} else {
/*
*
* if(coordlazos(u,1)==2) % Si ya es simple, copiamos el lazo simple tal cual.
*
* mislazos(numero,1)=2;
* for(t=2:5)
*
* mislazos(numero,t)=coordlazos(u,t);
*
* end
*
* % Metemos tambien R', rgm y Xc.
* mislazos(numero,6)=coordlazos(u,10);
* mislazos(numero,7)=coordlazos(u,11);
* mislazos(numero,8)=coordlazos(u,12);
* mislazos(numero,9)=coordlazos(u,15);
* numero=numero+1;
*
* end
*
* if(coordlazos(u,1)==3) % Si es de 3 conductores salen 2 lazos simples con conductor comun.
*
* % AQUI FALTA LO DE OBTENER LAS XC DE LAZO CONOCIENDO LAS DE
* % CONDUCTOR. ESTA FASILITO.
*
*
*
*
* % LAZO 1
* mislazos(numero,1)=2;
* for(t=2:5)
* mislazos(numero,t)=coordlazos(u,t);
* end
* % Metemos tambien el R', rgm y Xc.
* mislazos(numero,6)=coordlazos(u,10);
* mislazos(numero,7)=coordlazos(u,11);
*
* numero=numero+1;
*
* % LAZO 2
* mislazos(numero,1)=2;
* for(t=2:5)
* mislazos(numero,t)=coordlazos(u,t+2);
* end
* % Metemos tambien el R', rgm y Xc.
* mislazos(numero,6)=coordlazos(u,10);
* mislazos(numero,7)=coordlazos(u,11);
*
* numero=numero+1;
*
* end
*
* if(coordlazos(u,1)==4) % Si es de 4 conductores salen 2 lazos simples pero sin conductor comun.
*
* % Primer Lazo
* mislazos(numero,1)=2;
* for(t=2:5)
* mislazos(numero,t)=coordlazos(u,t);
* end
* % Metemos tambien R', rgm y Xc.
* mislazos(numero,6)=coordlazos(u,10);
* mislazos(numero,7)=coordlazos(u,11);
* mislazos(numero,8)=coordlazos(u,12);
* mislazos(numero,9)=coordlazos(u,15);
*
* numero=numero+1;
*
*
* % Segundo Lazo
* mislazos(numero,1)=2;
* for(t=6:9)
* mislazos(numero,t-4)=coordlazos(u,t);
* end
* % Metemos tambien el R'(posicion 10) y la rgm(posicion 11).
* mislazos(numero,6)=coordlazos(u,10);
* mislazos(numero,7)=coordlazos(u,11);
* mislazos(numero,8)=coordlazos(u,13);
* mislazos(numero,9)=coordlazos(u,15);
*
* numero=numero+1;
*
* end
*
* end
*/
for (; ; ) {
if (mclEqBool(
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 1),
_mxarray2_)) {
mclArrayAssign2(
mislazos,
_mxarray2_,
mclVv(numero, "numero"),
_mxarray0_);
{
int v_0 = mclForIntStart(2);
int e_0 = 5;
if (v_0 > e_0) {
mlfAssign(&t, _mxarray1_);
} else {
for (; ; ) {
mclArrayAssign2(
mislazos,
mclIntArrayRef2(
mclVa(coordlazos, "coordlazos"), v_, v_0),
mclVv(numero, "numero"),
mlfScalar(v_0));
if (v_0 == e_0) {
break;
}
++v_0;
}
mlfAssign(&t, mlfScalar(v_0));
}
}
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 10),
mclVv(numero, "numero"),
_mxarray3_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 11),
mclVv(numero, "numero"),
_mxarray4_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 12),
mclVv(numero, "numero"),
_mxarray5_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 15),
mclVv(numero, "numero"),
_mxarray6_);
mlfAssign(
&numero, mclPlus(mclVv(numero, "numero"), _mxarray0_));
}
if (mclEqBool(
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 1),
_mxarray7_)) {
mclArrayAssign2(
mislazos,
_mxarray2_,
mclVv(numero, "numero"),
_mxarray0_);
{
int v_1 = mclForIntStart(2);
int e_1 = 5;
if (v_1 > e_1) {
mlfAssign(&t, _mxarray1_);
} else {
for (; ; ) {
mclArrayAssign2(
mislazos,
mclIntArrayRef2(
mclVa(coordlazos, "coordlazos"), v_, v_1),
mclVv(numero, "numero"),
mlfScalar(v_1));
if (v_1 == e_1) {
break;
}
++v_1;
}
mlfAssign(&t, mlfScalar(v_1));
}
}
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 10),
mclVv(numero, "numero"),
_mxarray3_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 11),
mclVv(numero, "numero"),
_mxarray4_);
mlfAssign(
&numero, mclPlus(mclVv(numero, "numero"), _mxarray0_));
mclArrayAssign2(
mislazos,
_mxarray2_,
mclVv(numero, "numero"),
_mxarray0_);
{
int v_2 = mclForIntStart(2);
int e_2 = 5;
if (v_2 > e_2) {
mlfAssign(&t, _mxarray1_);
} else {
for (; ; ) {
mclArrayAssign2(
mislazos,
mclIntArrayRef2(
mclVa(coordlazos, "coordlazos"),
v_,
v_2 + 2),
mclVv(numero, "numero"),
mlfScalar(v_2));
if (v_2 == e_2) {
break;
}
++v_2;
}
mlfAssign(&t, mlfScalar(v_2));
}
}
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 10),
mclVv(numero, "numero"),
_mxarray3_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 11),
mclVv(numero, "numero"),
_mxarray4_);
mlfAssign(
&numero, mclPlus(mclVv(numero, "numero"), _mxarray0_));
}
if (mclEqBool(
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 1),
_mxarray8_)) {
mclArrayAssign2(
mislazos,
_mxarray2_,
mclVv(numero, "numero"),
_mxarray0_);
{
int v_3 = mclForIntStart(2);
int e_3 = 5;
if (v_3 > e_3) {
mlfAssign(&t, _mxarray1_);
} else {
for (; ; ) {
mclArrayAssign2(
mislazos,
mclIntArrayRef2(
mclVa(coordlazos, "coordlazos"), v_, v_3),
mclVv(numero, "numero"),
mlfScalar(v_3));
if (v_3 == e_3) {
break;
}
++v_3;
}
mlfAssign(&t, mlfScalar(v_3));
}
}
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 10),
mclVv(numero, "numero"),
_mxarray3_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 11),
mclVv(numero, "numero"),
_mxarray4_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 12),
mclVv(numero, "numero"),
_mxarray5_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 15),
mclVv(numero, "numero"),
_mxarray6_);
mlfAssign(
&numero, mclPlus(mclVv(numero, "numero"), _mxarray0_));
mclArrayAssign2(
mislazos,
_mxarray2_,
mclVv(numero, "numero"),
_mxarray0_);
{
int v_4 = mclForIntStart(6);
int e_4 = 9;
if (v_4 > e_4) {
mlfAssign(&t, _mxarray1_);
} else {
for (; ; ) {
mclArrayAssign2(
mislazos,
mclIntArrayRef2(
mclVa(coordlazos, "coordlazos"), v_, v_4),
mclVv(numero, "numero"),
mlfScalar(v_4 - 4));
if (v_4 == e_4) {
break;
}
++v_4;
}
mlfAssign(&t, mlfScalar(v_4));
}
}
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 10),
mclVv(numero, "numero"),
_mxarray3_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 11),
mclVv(numero, "numero"),
_mxarray4_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 13),
mclVv(numero, "numero"),
_mxarray5_);
mclArrayAssign2(
mislazos,
mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), v_, 15),
mclVv(numero, "numero"),
_mxarray6_);
mlfAssign(
&numero, mclPlus(mclVv(numero, "numero"), _mxarray0_));
}
if (v_ == e_) {
break;
}
++v_;
}
mlfAssign(&u, mlfScalar(v_));
}
}
/*
*
* m=size(mislazos,1); % Obtenemos el numero de lazos simples.
*/
mlfAssign(
&m,
mlfSize(mclValueVarargout(), mclVv(*mislazos, "mislazos"), _mxarray0_));
/*
* n=size(coordcond,1); % Obtenemos el numero de fases.
*/
mlfAssign(
&n,
mlfSize(mclValueVarargout(), mclVa(coordcond, "coordcond"), _mxarray0_));
/*
*
* % Matriz Z'
* for fila=1:m
*/
{
int v_ = mclForIntStart(1);
int e_ = mclForIntEnd(mclVv(m, "m"));
if (v_ > e_) {
mlfAssign(&fila, _mxarray1_);
} else {
/*
*
* for columna=1:m
*
* R=2*mislazos(fila,6); % Resistencia por unidad de longitud DE LAZO.
*
* % El calculo de X dependera de si estamos o no en la diagonal.
*
* if(fila==columna) % Si estamos en la diagonal.
*
* s=sqrt((mislazos(fila,2)-mislazos(fila,4))^2+(mislazos(fila,3)-mislazos(fila,5))^2);
*
* X=2*f*4*pi*(1e-7)*log(s/mislazos(fila,7));
*
* % Aqui hay que ajustar la inductancia segun el factor de
* % compensacion que se haya especificado.
*
* if mislazos(fila,9)==0 % Si es cero, viene dado como capacidad
*
* Xprima=-1/(i*2*pi*f*mislazos(fila,8));
* X=X+Xprima;
*
* else % Si no, es simplemente una reduccion de la inductancia
*
* X=X*(1-mislazos(fila,8));
*
* end
*
* Z(fila,columna)=R+j*X;
*
* else % Si no estamos en la diagonal.
*
* % distancias
* dI1L2=sqrt((mislazos(fila,2)-mislazos(columna,4))^2+(mislazos(fila,3)-mislazos(columna,5))^2);
* if dI1L2==0
* dI1L2=mislazos(fila,7);
* end
* dI2L1=sqrt((mislazos(fila,4)-mislazos(columna,2))^2+(mislazos(fila,5)-mislazos(columna,3))^2);
* if dI2L1==0
* dI2L1=mislazos(fila,7);
* end
* dI1L1=sqrt((mislazos(fila,2)-mislazos(columna,2))^2+(mislazos(fila,3)-mislazos(columna,3))^2);
* dI2L2=sqrt((mislazos(fila,4)-mislazos(columna,4))^2+(mislazos(fila,5)-mislazos(columna,5))^2);
*
* % Ahora calculamos X'
* X=2*pi*f*4*pi*(1e-7)/(2*pi)*log(dI1L2*dI2L1/(dI1L1*dI2L2));
*
* Z(fila,columna)=j*X;
*
* end
*
* end
*
* end
*/
for (; ; ) {
int v_5 = mclForIntStart(1);
int e_5 = mclForIntEnd(mclVv(m, "m"));
if (v_5 > e_5) {
mlfAssign(&columna, _mxarray1_);
} else {
for (; ; ) {
mlfAssign(
&R,
mclMtimes(
_mxarray2_,
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 6)));
if (mclEqBool(mlfScalar(v_), mlfScalar(v_5))) {
mlfAssign(
&s,
mlfSqrt(
mclPlus(
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 2),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 4)),
_mxarray2_),
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 3),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 5)),
_mxarray2_))));
mlfAssign(
&X,
mclMtimes(
mclMtimes(
mclMtimes(
mclMtimes(
mclMtimes(_mxarray2_, mclVa(f, "f")),
_mxarray8_),
_mxarray9_),
_mxarray10_),
mlfLog(
mclMrdivide(
mclVv(s, "s"),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 7)))));
if (mclEqBool(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 9),
_mxarray11_)) {
mlfAssign(
&Xprima,
mclMrdivide(
_mxarray12_,
mclMtimes(
mclMtimes(_mxarray13_, mclVa(f, "f")),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 8))));
mlfAssign(
&X,
mclPlus(
mclVv(X, "X"), mclVv(Xprima, "Xprima")));
} else {
mlfAssign(
&X,
mclMtimes(
mclVv(X, "X"),
mclMinus(
_mxarray0_,
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 8))));
}
mclIntArrayAssign2(
&Z,
mclPlus(
mclVv(R, "R"),
mclMtimes(_mxarray14_, mclVv(X, "X"))),
v_,
v_5);
} else {
mlfAssign(
&dI1L2,
mlfSqrt(
mclPlus(
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 2),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 4)),
_mxarray2_),
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 3),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 5)),
_mxarray2_))));
if (mclEqBool(mclVv(dI1L2, "dI1L2"), _mxarray11_)) {
mlfAssign(
&dI1L2,
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 7));
}
mlfAssign(
&dI2L1,
mlfSqrt(
mclPlus(
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 4),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 2)),
_mxarray2_),
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 5),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 3)),
_mxarray2_))));
if (mclEqBool(mclVv(dI2L1, "dI2L1"), _mxarray11_)) {
mlfAssign(
&dI2L1,
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 7));
}
mlfAssign(
&dI1L1,
mlfSqrt(
mclPlus(
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 2),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 2)),
_mxarray2_),
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 3),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 3)),
_mxarray2_))));
mlfAssign(
&dI2L2,
mlfSqrt(
mclPlus(
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 4),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 4)),
_mxarray2_),
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 5),
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_5, 5)),
_mxarray2_))));
mlfAssign(
&X,
mclMtimes(
mclMrdivide(
mclMtimes(
mclMtimes(
mclMtimes(
mclMtimes(_mxarray15_, mclVa(f, "f")),
_mxarray8_),
_mxarray9_),
_mxarray10_),
_mxarray15_),
mlfLog(
mclMrdivide(
mclMtimes(
mclVv(dI1L2, "dI1L2"),
mclVv(dI2L1, "dI2L1")),
mclMtimes(
mclVv(dI1L1, "dI1L1"),
mclVv(dI2L2, "dI2L2"))))));
mclIntArrayAssign2(
&Z,
mclMtimes(_mxarray14_, mclVv(X, "X")),
v_,
v_5);
}
if (v_5 == e_5) {
break;
}
++v_5;
}
mlfAssign(&columna, mlfScalar(v_5));
}
if (v_ == e_) {
break;
}
++v_;
}
mlfAssign(&fila, mlfScalar(v_));
}
}
/*
*
* % Matriz Zp'
* for fila=1:m
*/
{
int v_ = mclForIntStart(1);
int e_ = mclForIntEnd(mclVv(m, "m"));
if (v_ > e_) {
mlfAssign(&fila, _mxarray1_);
} else {
/*
*
* % Lazo simple
* if(mislazos(fila,1)==2)
*
* for columna=1:n
*
* % Calculamos las distancias.
*
* dI2k=sqrt((mislazos(fila,4)-coordcond(columna,1))^2+(mislazos(fila,5)-coordcond(columna,2))^2);
* dI1k=sqrt((mislazos(fila,2)-coordcond(columna,1))^2+(mislazos(fila,3)-coordcond(columna,2))^2);
*
* X=2*pi*f*4*pi*(1e-7)/(2*pi)*log(dI2k/dI1k);
*
* Zp(fila,columna)=j*X;
*
* end
*
* end
*
* end
*/
for (; ; ) {
if (mclEqBool(
mclIntArrayRef2(mclVv(*mislazos, "mislazos"), v_, 1),
_mxarray2_)) {
int v_6 = mclForIntStart(1);
int e_6 = mclForIntEnd(mclVv(n, "n"));
if (v_6 > e_6) {
mlfAssign(&columna, _mxarray1_);
} else {
for (; ; ) {
mlfAssign(
&dI2k,
mlfSqrt(
mclPlus(
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 4),
mclIntArrayRef2(
mclVa(coordcond, "coordcond"), v_6, 1)),
_mxarray2_),
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 5),
mclIntArrayRef2(
mclVa(coordcond, "coordcond"), v_6, 2)),
_mxarray2_))));
mlfAssign(
&dI1k,
mlfSqrt(
mclPlus(
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 2),
mclIntArrayRef2(
mclVa(coordcond, "coordcond"), v_6, 1)),
_mxarray2_),
mclMpower(
mclMinus(
mclIntArrayRef2(
mclVv(*mislazos, "mislazos"), v_, 3),
mclIntArrayRef2(
mclVa(coordcond, "coordcond"), v_6, 2)),
_mxarray2_))));
mlfAssign(
&X,
mclMtimes(
mclMrdivide(
mclMtimes(
mclMtimes(
mclMtimes(
mclMtimes(_mxarray15_, mclVa(f, "f")),
_mxarray8_),
_mxarray9_),
_mxarray10_),
_mxarray15_),
mlfLog(
mclMrdivide(
mclVv(dI2k, "dI2k"),
mclVv(dI1k, "dI1k")))));
mclIntArrayAssign2(
&Zp,
mclMtimes(_mxarray14_, mclVv(X, "X")),
v_,
v_6);
if (v_6 == e_6) {
break;
}
++v_6;
}
mlfAssign(&columna, mlfScalar(v_6));
}
}
if (v_ == e_) {
break;
}
++v_;
}
mlfAssign(&fila, mlfScalar(v_));
}
}
/*
*
* % Matriz Ip
* n=size(coordcond,1); % Obtenemos el numero de fases.
*/
mlfAssign(
&n,
mlfSize(mclValueVarargout(), mclVa(coordcond, "coordcond"), _mxarray0_));
/*
*
* for y=1:n
*/
{
int v_ = mclForIntStart(1);
int e_ = mclForIntEnd(mclVv(n, "n"));
if (v_ > e_) {
mlfAssign(&y, _mxarray1_);
} else {
/*
*
* Ip(y,1)=coordcond(y,3)*(cos(coordcond(y,4)*pi/180)+i*sin(coordcond(y,4)*pi/180));
*
* end
*/
for (; ; ) {
mclIntArrayAssign2(
&Ip,
mclMtimes(
mclIntArrayRef2(mclVa(coordcond, "coordcond"), v_, 3),
mclPlus(
mlfCos(
mclMrdivide(
mclMtimes(
mclIntArrayRef2(
mclVa(coordcond, "coordcond"), v_, 4),
_mxarray9_),
_mxarray16_)),
mclMtimes(
_mxarray14_,
mlfSin(
mclMrdivide(
mclMtimes(
mclIntArrayRef2(
mclVa(coordcond, "coordcond"), v_, 4),
_mxarray9_),
_mxarray16_))))),
v_,
1);
if (v_ == e_) {
break;
}
++v_;
}
mlfAssign(&y, mlfScalar(v_));
}
}
/*
*
* % Resultado
* Z;
*/
mclVv(Z, "Z");
/*
* Zp;
*/
mclVv(Zp, "Zp");
/*
* Ip;
*/
mclVv(Ip, "Ip");
/*
* Ilazos=-inv(Z)*Zp*Ip;
*/
mlfAssign(
&Ilazos,
mclMtimes(
mclMtimes(mclUminus(mlfInv(mclVv(Z, "Z"))), mclVv(Zp, "Zp")),
mclVv(Ip, "Ip")));
mclValidateOutput(Ilazos, 1, nargout_, "Ilazos", "matrices");
mclValidateOutput(*mislazos, 2, nargout_, "mislazos", "matrices");
mxDestroyArray(numero);
mxDestroyArray(u);
mxDestroyArray(t);
mxDestroyArray(m);
mxDestroyArray(n);
mxDestroyArray(fila);
mxDestroyArray(columna);
mxDestroyArray(R);
mxDestroyArray(s);
mxDestroyArray(X);
mxDestroyArray(Xprima);
mxDestroyArray(Z);
mxDestroyArray(dI1L2);
mxDestroyArray(dI2L1);
mxDestroyArray(dI1L1);
mxDestroyArray(dI2L2);
mxDestroyArray(dI2k);
mxDestroyArray(dI1k);
mxDestroyArray(Zp);
mxDestroyArray(y);
mxDestroyArray(Ip);
mxDestroyArray(ans);
mxDestroyArray(coordcond);
mxDestroyArray(coordlazos);
mxDestroyArray(f);
mclSetCurrentLocalFunctionTable(save_local_function_table_);
return Ilazos;
/*
*
*/
}
e-REdING. Biblioteca de la Escuela Superior de Ingenieros de Sevilla.
