/*
 * MATLAB Compiler: 3.0
 * Date: Wed Jul 06 02:27:15 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" "micampo.m" "matrices1lazo.m" "leeActivo.m" "leePasivo.m"
 * "matActivo.m" 
 */
#include "matrices1lazo.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_;

void InitializeModule_matrices1lazo(void) {
    _mxarray0_ = mclInitializeDouble(1.0);
    _mxarray1_ = mclInitializeDouble(2.0);
    _mxarray2_ = mclInitializeComplex(0.0, 1.0);
    _mxarray3_ = mclInitializeDouble(6.283185307179586);
    _mxarray4_ = mclInitializeDouble(1.2566370614359173e-06);
    _mxarray5_ = mclInitializeDouble(3.141592653589793);
    _mxarray6_ = mclInitializeComplex(0.0, 6.283185307179586);
    _mxarray7_ = mclInitializeDouble(1e-06);
    _mxarray8_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
    _mxarray9_ = mclInitializeDouble(3.0);
    _mxarray10_ = mclInitializeDouble(4.0);
    _mxarray11_ = mclInitializeDouble(1e-07);
    _mxarray12_ = mclInitializeDouble(180.0);
}

void TerminateModule_matrices1lazo(void) {
    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 * Mmatrices1lazo(mxArray * * mislazos,
                                int nargout_,
                                mxArray * f,
                                mxArray * coordlazos,
                                mxArray * coordcond);

_mexLocalFunctionTable _local_function_table_matrices1lazo
  = { 0, (mexFunctionTableEntry *)NULL };

/*
 * The function "mlfMatrices1lazo" contains the normal interface for the
 * "matrices1lazo" M-function from file "c:\matlab6p5\work\matrices1lazo.m"
 * (lines 1-207). This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
mxArray * mlfMatrices1lazo(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 = Mmatrices1lazo(&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 "mlxMatrices1lazo" contains the feval interface for the
 * "matrices1lazo" M-function from file "c:\matlab6p5\work\matrices1lazo.m"
 * (lines 1-207). The feval function calls the implementation version of
 * matrices1lazo through this function. This function processes any input
 * arguments and passes them to the implementation version of the function,
 * appearing above.
 */
void mlxMatrices1lazo(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: matrices1lazo Line: 20 Colum"
            "n: 1 The function \"matrices1lazo\" was called wit"
            "h more than the declared number of outputs (2)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: matrices1lazo Line: 20 Colum"
            "n: 1 The function \"matrices1lazo\" was called wit"
            "h 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] = Mmatrices1lazo(&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 "Mmatrices1lazo" is the implementation version of the
 * "matrices1lazo" M-function from file "c:\matlab6p5\work\matrices1lazo.m"
 * (lines 1-207). 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 * Mmatrices1lazo(mxArray * * mislazos,
                                int nargout_,
                                mxArray * f,
                                mxArray * coordlazos,
                                mxArray * coordcond) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_matrices1lazo);
    mxArray * Ilazos = NULL;
    mxArray * ans = NULL;
    mxArray * Ip = NULL;
    mxArray * y = NULL;
    mxArray * Zp = NULL;
    mxArray * X = NULL;
    mxArray * dI1k = NULL;
    mxArray * dI2k = NULL;
    mxArray * columna = NULL;
    mxArray * fila = NULL;
    mxArray * n = NULL;
    mxArray * m = NULL;
    mxArray * d24 = NULL;
    mxArray * d34 = NULL;
    mxArray * d14 = NULL;
    mxArray * Z12L = NULL;
    mxArray * Z22L = NULL;
    mxArray * Z11L = NULL;
    mxArray * Z33 = NULL;
    mxArray * Z22 = NULL;
    mxArray * Z23 = NULL;
    mxArray * Z13 = NULL;
    mxArray * Z12 = NULL;
    mxArray * d13 = NULL;
    mxArray * d23 = NULL;
    mxArray * Xc3 = NULL;
    mxArray * Xc2 = NULL;
    mxArray * t = NULL;
    mxArray * Z = NULL;
    mxArray * Z11 = NULL;
    mxArray * d12 = NULL;
    mxArray * Xc1 = NULL;
    mxArray * rgm = NULL;
    mxArray * R = NULL;
    mxArray * numero = NULL;
    mclCopyArray(&f);
    mclCopyArray(&coordlazos);
    mclCopyArray(&coordcond);
    /*
     * 
     * % Sacamos la Z' de la configuracion que nos pasan.
     * numero=1;
     */
    mlfAssign(&numero, _mxarray0_);
    /*
     * 
     * if(coordlazos(1,1)==2)  % Lazo simple.     
     */
    if (mclEqBool(
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 1), _mxarray1_)) {
        /*
         * 
         * % Datos del conductor.
         * R=coordlazos(1,10);
         */
        mlfAssign(&R, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 10));
        /*
         * rgm=coordlazos(1,11);
         */
        mlfAssign(
          &rgm, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 11));
        /*
         * Xc1=coordlazos(1,12);
         */
        mlfAssign(
          &Xc1, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 12));
        /*
         * 
         * % Distancia
         * d12=sqrt( (coordlazos(1,4)-coordlazos(1,2))^2 + (coordlazos(1,5)-coordlazos(1,3))^2);
         */
        mlfAssign(
          &d12,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3)),
                _mxarray1_))));
        /*
         * 
         * % Elementos de Z'        
         * % Si el ultimo elemento es 1, es que nos estan pasando Xci en pu.
         * if coordlazos(1,15)==1 
         */
        if (mclEqBool(
              mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 15),
              _mxarray0_)) {
            /*
             * 
             * Z11=2*R+(1-Xc1)*j*(2*pi*f)*(4*pi*1e-7)/(pi)*log(d12/rgm);
             */
            mlfAssign(
              &Z11,
              mclPlus(
                mclMtimes(_mxarray1_, mclVv(R, "R")),
                mclMtimes(
                  mclMrdivide(
                    mclMtimes(
                      mclMtimes(
                        mclMtimes(
                          mclMinus(_mxarray0_, mclVv(Xc1, "Xc1")), _mxarray2_),
                        mclMtimes(_mxarray3_, mclVa(f, "f"))),
                      _mxarray4_),
                    _mxarray5_),
                  mlfLog(mclMrdivide(mclVv(d12, "d12"), mclVv(rgm, "rgm"))))));
        /*
         * 
         * else % SI no, Xc1 viene dada en uOhmios.
         */
        } else {
            /*
             * 
             * Z11=2*R+j*2*pi*f*(4*pi*1e-7)*log(1/rgm)-j/(2*pi*f*1e-6*Xc1);
             */
            mlfAssign(
              &Z11,
              mclMinus(
                mclPlus(
                  mclMtimes(_mxarray1_, mclVv(R, "R")),
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray6_, mclVa(f, "f")), _mxarray4_),
                    mlfLog(mclMrdivide(_mxarray0_, mclVv(rgm, "rgm"))))),
                mclMrdivide(
                  _mxarray2_,
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray3_, mclVa(f, "f")), _mxarray7_),
                    mclVv(Xc1, "Xc1")))));
        /*
         * 
         * end
         */
        }
        /*
         * 
         * % La matriz Z queda:
         * Z=[Z11];
         */
        mlfAssign(&Z, mclVv(Z11, "Z11"));
        /*
         * 
         * % La matriz mislazos es:
         * mislazos(numero,1)=2;
         */
        mclArrayAssign2(
          mislazos, _mxarray1_, mclVv(numero, "numero"), _mxarray0_);
        /*
         * for(t=2:5)
         */
        {
            int v_ = mclForIntStart(2);
            int e_ = 5;
            if (v_ > e_) {
                mlfAssign(&t, _mxarray8_);
            } else {
                /*
                 * 
                 * mislazos(1,t)=coordlazos(1,t);
                 * 
                 * end
                 */
                for (; ; ) {
                    mclIntArrayAssign2(
                      mislazos,
                      mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, v_),
                      1,
                      v_);
                    if (v_ == e_) {
                        break;
                    }
                    ++v_;
                }
                mlfAssign(&t, mlfScalar(v_));
            }
        }
        /*
         * 
         * % Metemos tambien R', rgm y Xc.
         * mislazos(1,6)=coordlazos(1,10);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 10),
          1,
          6);
        /*
         * mislazos(1,7)=coordlazos(1,11);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 11),
          1,
          7);
        /*
         * mislazos(1,8)=coordlazos(1,12);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 12),
          1,
          8);
        /*
         * mislazos(1,9)=coordlazos(1,15);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 15),
          1,
          9);
    /*
     * 
     * elseif(coordlazos(1,1)==3)  % Lazo doble conductor comun
     */
    } else if (mclEqBool(
                 mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 1),
                 _mxarray9_)) {
        /*
         * 
         * % Cogemos las Xci
         * Xc1=coordlazos(1,12);
         */
        mlfAssign(
          &Xc1, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 12));
        /*
         * Xc2=coordlazos(1,13);
         */
        mlfAssign(
          &Xc2, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 13));
        /*
         * Xc3=coordlazos(1,14);
         */
        mlfAssign(
          &Xc3, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 14));
        /*
         * 
         * % Cogemos la R' y rgm de conductor.
         * R=coordlazos(1,10);
         */
        mlfAssign(&R, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 10));
        /*
         * rgm=coordlazos(1,11);
         */
        mlfAssign(
          &rgm, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 11));
        /*
         * 
         * % Calculamos las distancias
         * d12=sqrt( (coordlazos(1,4)-coordlazos(1,2))^2 + (coordlazos(1,5)-coordlazos(1,3))^2);
         */
        mlfAssign(
          &d12,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3)),
                _mxarray1_))));
        /*
         * d23=sqrt( (coordlazos(1,6)-coordlazos(1,4))^2 + (coordlazos(1,7)-coordlazos(1,5))^2);
         */
        mlfAssign(
          &d23,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 6),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 7),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5)),
                _mxarray1_))));
        /*
         * d13=sqrt( (coordlazos(1,6)-coordlazos(1,2))^2 + (coordlazos(1,7)-coordlazos(1,3))^2);
         */
        mlfAssign(
          &d13,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 6),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 7),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3)),
                _mxarray1_))));
        /*
         * 
         * % Los elementos no diagonales son los mismos, esten Xci en uF o en
         * % pu.
         * Z12=j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/d12);
         */
        mlfAssign(
          &Z12,
          mclMtimes(
            mclMrdivide(
              mclMtimes(
                mclMtimes(_mxarray2_, mclMtimes(_mxarray3_, mclVa(f, "f"))),
                _mxarray4_),
              _mxarray3_),
            mlfLog(mclMrdivide(_mxarray0_, mclVv(d12, "d12")))));
        /*
         * Z13=j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/d13);
         */
        mlfAssign(
          &Z13,
          mclMtimes(
            mclMrdivide(
              mclMtimes(
                mclMtimes(_mxarray2_, mclMtimes(_mxarray3_, mclVa(f, "f"))),
                _mxarray4_),
              _mxarray3_),
            mlfLog(mclMrdivide(_mxarray0_, mclVv(d13, "d13")))));
        /*
         * Z23=j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/d23);
         */
        mlfAssign(
          &Z23,
          mclMtimes(
            mclMrdivide(
              mclMtimes(
                mclMtimes(_mxarray2_, mclMtimes(_mxarray3_, mclVa(f, "f"))),
                _mxarray4_),
              _mxarray3_),
            mlfLog(mclMrdivide(_mxarray0_, mclVv(d23, "d23")))));
        /*
         * 
         * % Si el ultimo elemento es 1, es que nos estan pasando Xci en pu.
         * if coordlazos(1,15)==1 
         */
        if (mclEqBool(
              mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 15),
              _mxarray0_)) {
            /*
             * 
             * Z11=R+(1-Xc1)*j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/rgm);
             */
            mlfAssign(
              &Z11,
              mclPlus(
                mclVv(R, "R"),
                mclMtimes(
                  mclMrdivide(
                    mclMtimes(
                      mclMtimes(
                        mclMtimes(
                          mclMinus(_mxarray0_, mclVv(Xc1, "Xc1")), _mxarray2_),
                        mclMtimes(_mxarray3_, mclVa(f, "f"))),
                      _mxarray4_),
                    _mxarray3_),
                  mlfLog(mclMrdivide(_mxarray0_, mclVv(rgm, "rgm"))))));
            /*
             * Z22=R+(1-Xc2)*j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/rgm);
             */
            mlfAssign(
              &Z22,
              mclPlus(
                mclVv(R, "R"),
                mclMtimes(
                  mclMrdivide(
                    mclMtimes(
                      mclMtimes(
                        mclMtimes(
                          mclMinus(_mxarray0_, mclVv(Xc2, "Xc2")), _mxarray2_),
                        mclMtimes(_mxarray3_, mclVa(f, "f"))),
                      _mxarray4_),
                    _mxarray3_),
                  mlfLog(mclMrdivide(_mxarray0_, mclVv(rgm, "rgm"))))));
            /*
             * Z33=R+(1-Xc3)*j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/rgm);        
             */
            mlfAssign(
              &Z33,
              mclPlus(
                mclVv(R, "R"),
                mclMtimes(
                  mclMrdivide(
                    mclMtimes(
                      mclMtimes(
                        mclMtimes(
                          mclMinus(_mxarray0_, mclVv(Xc3, "Xc3")), _mxarray2_),
                        mclMtimes(_mxarray3_, mclVa(f, "f"))),
                      _mxarray4_),
                    _mxarray3_),
                  mlfLog(mclMrdivide(_mxarray0_, mclVv(rgm, "rgm"))))));
        /*
         * 
         * else
         */
        } else {
            /*
             * 
             * Z11=R+j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/rgm)-j/((2*pi*f)*(1e-6)*Xc1);
             */
            mlfAssign(
              &Z11,
              mclMinus(
                mclPlus(
                  mclVv(R, "R"),
                  mclMtimes(
                    mclMrdivide(
                      mclMtimes(
                        mclMtimes(
                          _mxarray2_, mclMtimes(_mxarray3_, mclVa(f, "f"))),
                        _mxarray4_),
                      _mxarray3_),
                    mlfLog(mclMrdivide(_mxarray0_, mclVv(rgm, "rgm"))))),
                mclMrdivide(
                  _mxarray2_,
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray3_, mclVa(f, "f")), _mxarray7_),
                    mclVv(Xc1, "Xc1")))));
            /*
             * Z22=R+j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/rgm)-j/((2*pi*f)*(1e-6)*Xc2);           
             */
            mlfAssign(
              &Z22,
              mclMinus(
                mclPlus(
                  mclVv(R, "R"),
                  mclMtimes(
                    mclMrdivide(
                      mclMtimes(
                        mclMtimes(
                          _mxarray2_, mclMtimes(_mxarray3_, mclVa(f, "f"))),
                        _mxarray4_),
                      _mxarray3_),
                    mlfLog(mclMrdivide(_mxarray0_, mclVv(rgm, "rgm"))))),
                mclMrdivide(
                  _mxarray2_,
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray3_, mclVa(f, "f")), _mxarray7_),
                    mclVv(Xc2, "Xc2")))));
            /*
             * Z11=R+j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log(1/rgm)-j/((2*pi*f)*(1e-6)*Xc3);
             */
            mlfAssign(
              &Z11,
              mclMinus(
                mclPlus(
                  mclVv(R, "R"),
                  mclMtimes(
                    mclMrdivide(
                      mclMtimes(
                        mclMtimes(
                          _mxarray2_, mclMtimes(_mxarray3_, mclVa(f, "f"))),
                        _mxarray4_),
                      _mxarray3_),
                    mlfLog(mclMrdivide(_mxarray0_, mclVv(rgm, "rgm"))))),
                mclMrdivide(
                  _mxarray2_,
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray3_, mclVa(f, "f")), _mxarray7_),
                    mclVv(Xc3, "Xc3")))));
        /*
         * 
         * end
         */
        }
        /*
         * 
         * % Por tanto, las inductancias de lazo seran:
         * Z11L=Z11+Z22-2*Z12;
         */
        mlfAssign(
          &Z11L,
          mclMinus(
            mclPlus(mclVv(Z11, "Z11"), mclVv(Z22, "Z22")),
            mclMtimes(_mxarray1_, mclVv(Z12, "Z12"))));
        /*
         * Z22L=Z22+Z33-2*Z23;
         */
        mlfAssign(
          &Z22L,
          mclMinus(
            mclPlus(mclVv(Z22, "Z22"), mclVv(Z33, "Z33")),
            mclMtimes(_mxarray1_, mclVv(Z23, "Z23"))));
        /*
         * Z12L=Z13-Z23-Z12+Z22;
         */
        mlfAssign(
          &Z12L,
          mclPlus(
            mclMinus(
              mclMinus(mclVv(Z13, "Z13"), mclVv(Z23, "Z23")),
              mclVv(Z12, "Z12")),
            mclVv(Z22, "Z22")));
        /*
         * 
         * % Y la matriz Z' es:
         * Z=[Z11L Z12L ; Z12L Z22L];
         */
        mlfAssign(
          &Z,
          mlfVertcat(
            mlfHorzcat(mclVv(Z11L, "Z11L"), mclVv(Z12L, "Z12L"), NULL),
            mlfHorzcat(mclVv(Z12L, "Z12L"), mclVv(Z22L, "Z22L"), NULL),
            NULL));
        /*
         * 
         * % La matriz mislazos queda
         * mislazos(1,1)=2;
         */
        mclIntArrayAssign2(mislazos, _mxarray1_, 1, 1);
        /*
         * mislazos(1,2)=coordlazos(1,2);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2),
          1,
          2);
        /*
         * mislazos(1,3)=coordlazos(1,3);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3),
          1,
          3);
        /*
         * mislazos(1,4)=coordlazos(1,4);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4),
          1,
          4);
        /*
         * mislazos(1,5)=coordlazos(1,5);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5),
          1,
          5);
        /*
         * mislazos(2,1)=2;
         */
        mclIntArrayAssign2(mislazos, _mxarray1_, 2, 1);
        /*
         * mislazos(2,2)=coordlazos(1,4);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4),
          2,
          2);
        /*
         * mislazos(2,3)=coordlazos(1,5);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5),
          2,
          3);
        /*
         * mislazos(2,4)=coordlazos(1,6);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 6),
          2,
          4);
        /*
         * mislazos(2,5)=coordlazos(1,7);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 7),
          2,
          5);
    /*
     * 
     * elseif(coordlazos(1,1)==4)  % Lazo doble sin conductor comun.
     */
    } else if (mclEqBool(
                 mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 1),
                 _mxarray10_)) {
        /*
         * 
         * % Cogemos las Xci
         * Xc1=coordlazos(1,12);    
         */
        mlfAssign(
          &Xc1, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 12));
        /*
         * Xc3=coordlazos(1,14);
         */
        mlfAssign(
          &Xc3, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 14));
        /*
         * 
         * % Cogemos la R' y rgm de conductor.
         * R=coordlazos(1,10);
         */
        mlfAssign(&R, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 10));
        /*
         * rgm=coordlazos(1,11);
         */
        mlfAssign(
          &rgm, mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 11));
        /*
         * 
         * % Calculamos las distancias
         * d12=sqrt( (coordlazos(1,4)-coordlazos(1,2))^2 + (coordlazos(1,5)-coordlazos(1,3))^2);
         */
        mlfAssign(
          &d12,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3)),
                _mxarray1_))));
        /*
         * d23=sqrt( (coordlazos(1,6)-coordlazos(1,4))^2 + (coordlazos(1,7)-coordlazos(1,5))^2);
         */
        mlfAssign(
          &d23,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 6),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 7),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5)),
                _mxarray1_))));
        /*
         * d13=sqrt( (coordlazos(1,6)-coordlazos(1,2))^2 + (coordlazos(1,7)-coordlazos(1,3))^2);
         */
        mlfAssign(
          &d13,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 6),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 7),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3)),
                _mxarray1_))));
        /*
         * d14=sqrt( (coordlazos(1,8)-coordlazos(1,2))^2 + (coordlazos(1,9)-coordlazos(1,3))^2);
         */
        mlfAssign(
          &d14,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 8),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 9),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3)),
                _mxarray1_))));
        /*
         * d34=sqrt( (coordlazos(1,8)-coordlazos(1,6))^2 + (coordlazos(1,9)-coordlazos(1,7))^2);
         */
        mlfAssign(
          &d34,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 8),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 6)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 9),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 7)),
                _mxarray1_))));
        /*
         * d24=sqrt( (coordlazos(1,8)-coordlazos(1,4))^2 + (coordlazos(1,9)-coordlazos(1,5))^2);
         */
        mlfAssign(
          &d24,
          mlfSqrt(
            mclPlus(
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 8),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4)),
                _mxarray1_),
              mclMpower(
                mclMinus(
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 9),
                  mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5)),
                _mxarray1_))));
        /*
         * 
         * Z12=R+j*(2*pi*f)*(4*pi*1e-7)/(2*pi)*log((d14*d23/(d13*d24)));
         */
        mlfAssign(
          &Z12,
          mclPlus(
            mclVv(R, "R"),
            mclMtimes(
              mclMrdivide(
                mclMtimes(
                  mclMtimes(_mxarray2_, mclMtimes(_mxarray3_, mclVa(f, "f"))),
                  _mxarray4_),
                _mxarray3_),
              mlfLog(
                mclMrdivide(
                  mclMtimes(mclVv(d14, "d14"), mclVv(d23, "d23")),
                  mclMtimes(mclVv(d13, "d13"), mclVv(d24, "d24")))))));
        /*
         * 
         * % Si el ultimo elemento es 1, es que nos estan pasando Xci en pu.
         * if coordlazos(1,15)==1 
         */
        if (mclEqBool(
              mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 15),
              _mxarray0_)) {
            /*
             * 
             * Z11=2*R+(1-Xc1)*j*(2*pi*f)*(4*pi*1e-7)/(pi)*log(d12/rgm);
             */
            mlfAssign(
              &Z11,
              mclPlus(
                mclMtimes(_mxarray1_, mclVv(R, "R")),
                mclMtimes(
                  mclMrdivide(
                    mclMtimes(
                      mclMtimes(
                        mclMtimes(
                          mclMinus(_mxarray0_, mclVv(Xc1, "Xc1")), _mxarray2_),
                        mclMtimes(_mxarray3_, mclVa(f, "f"))),
                      _mxarray4_),
                    _mxarray5_),
                  mlfLog(mclMrdivide(mclVv(d12, "d12"), mclVv(rgm, "rgm"))))));
            /*
             * Z22=2*R+(1-Xc3)*j*(2*pi*f)*(4*pi*1e-7)/(pi)*log(d34/rgm);
             */
            mlfAssign(
              &Z22,
              mclPlus(
                mclMtimes(_mxarray1_, mclVv(R, "R")),
                mclMtimes(
                  mclMrdivide(
                    mclMtimes(
                      mclMtimes(
                        mclMtimes(
                          mclMinus(_mxarray0_, mclVv(Xc3, "Xc3")), _mxarray2_),
                        mclMtimes(_mxarray3_, mclVa(f, "f"))),
                      _mxarray4_),
                    _mxarray5_),
                  mlfLog(mclMrdivide(mclVv(d34, "d34"), mclVv(rgm, "rgm"))))));
        /*
         * 
         * else % SI no, Xc1 viene dada en uF.
         */
        } else {
            /*
             * 
             * Z11=2*R+j*2*pi*f*(4*pi*1e-7)*log(d12/rgm)-j/(2*pi*f*1e-6*Xc1);
             */
            mlfAssign(
              &Z11,
              mclMinus(
                mclPlus(
                  mclMtimes(_mxarray1_, mclVv(R, "R")),
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray6_, mclVa(f, "f")), _mxarray4_),
                    mlfLog(mclMrdivide(mclVv(d12, "d12"), mclVv(rgm, "rgm"))))),
                mclMrdivide(
                  _mxarray2_,
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray3_, mclVa(f, "f")), _mxarray7_),
                    mclVv(Xc1, "Xc1")))));
            /*
             * Z22=2*R+j*2*pi*f*(4*pi*1e-7)*log(d34/rgm)-j/(2*pi*f*1e-6*Xc1);
             */
            mlfAssign(
              &Z22,
              mclMinus(
                mclPlus(
                  mclMtimes(_mxarray1_, mclVv(R, "R")),
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray6_, mclVa(f, "f")), _mxarray4_),
                    mlfLog(mclMrdivide(mclVv(d34, "d34"), mclVv(rgm, "rgm"))))),
                mclMrdivide(
                  _mxarray2_,
                  mclMtimes(
                    mclMtimes(mclMtimes(_mxarray3_, mclVa(f, "f")), _mxarray7_),
                    mclVv(Xc1, "Xc1")))));
        /*
         * 
         * end
         */
        }
        /*
         * 
         * % La matriz Z queda
         * Z=[Z11 Z12; Z12 Z22];
         */
        mlfAssign(
          &Z,
          mlfVertcat(
            mlfHorzcat(mclVv(Z11, "Z11"), mclVv(Z12, "Z12"), NULL),
            mlfHorzcat(mclVv(Z12, "Z12"), mclVv(Z22, "Z22"), NULL),
            NULL));
        /*
         * 
         * % La matriz mislazos queda
         * mislazos(1,1)=2;
         */
        mclIntArrayAssign2(mislazos, _mxarray1_, 1, 1);
        /*
         * mislazos(1,2)=coordlazos(1,2);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 2),
          1,
          2);
        /*
         * mislazos(1,3)=coordlazos(1,3);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 3),
          1,
          3);
        /*
         * mislazos(1,4)=coordlazos(1,4);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 4),
          1,
          4);
        /*
         * mislazos(1,5)=coordlazos(1,5);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 5),
          1,
          5);
        /*
         * mislazos(2,1)=2;
         */
        mclIntArrayAssign2(mislazos, _mxarray1_, 2, 1);
        /*
         * mislazos(2,2)=coordlazos(1,6);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 6),
          2,
          2);
        /*
         * mislazos(2,3)=coordlazos(1,7);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 7),
          2,
          3);
        /*
         * mislazos(2,4)=coordlazos(1,8);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 8),
          2,
          4);
        /*
         * mislazos(2,5)=coordlazos(1,9);
         */
        mclIntArrayAssign2(
          mislazos,
          mclIntArrayRef2(mclVa(coordlazos, "coordlazos"), 1, 9),
          2,
          5);
    /*
     * 
     * end
     */
    }
    /*
     * 
     * m=size(Z,1);     % Obtenemos el numero de lazos simples.
     */
    mlfAssign(&m, mlfSize(mclValueVarargout(), mclVv(Z, "Z"), _mxarray0_));
    /*
     * n=size(coordcond,1);    % Obtenemos el numero de fases.
     */
    mlfAssign(
      &n,
      mlfSize(mclValueVarargout(), mclVa(coordcond, "coordcond"), _mxarray0_));
    /*
     * 
     * % Matriz Zp'    
     * for fila=1:m
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVv(m, "m"));
        if (v_ > e_) {
            mlfAssign(&fila, _mxarray8_);
        } else {
            /*
             * 
             * 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
             */
            for (; ; ) {
                int v_0 = mclForIntStart(1);
                int e_0 = mclForIntEnd(mclVv(n, "n"));
                if (v_0 > e_0) {
                    mlfAssign(&columna, _mxarray8_);
                } else {
                    for (; ; ) {
                        mlfAssign(
                          &dI2k,
                          mlfSqrt(
                            mclPlus(
                              mclMpower(
                                mclMinus(
                                  mclIntArrayRef2(
                                    mclVv(*mislazos, "mislazos"), v_, 4),
                                  mclIntArrayRef2(
                                    mclVa(coordcond, "coordcond"), v_0, 1)),
                                _mxarray1_),
                              mclMpower(
                                mclMinus(
                                  mclIntArrayRef2(
                                    mclVv(*mislazos, "mislazos"), v_, 5),
                                  mclIntArrayRef2(
                                    mclVa(coordcond, "coordcond"), v_0, 2)),
                                _mxarray1_))));
                        mlfAssign(
                          &dI1k,
                          mlfSqrt(
                            mclPlus(
                              mclMpower(
                                mclMinus(
                                  mclIntArrayRef2(
                                    mclVv(*mislazos, "mislazos"), v_, 2),
                                  mclIntArrayRef2(
                                    mclVa(coordcond, "coordcond"), v_0, 1)),
                                _mxarray1_),
                              mclMpower(
                                mclMinus(
                                  mclIntArrayRef2(
                                    mclVv(*mislazos, "mislazos"), v_, 3),
                                  mclIntArrayRef2(
                                    mclVa(coordcond, "coordcond"), v_0, 2)),
                                _mxarray1_))));
                        mlfAssign(
                          &X,
                          mclMtimes(
                            mclMrdivide(
                              mclMtimes(
                                mclMtimes(
                                  mclMtimes(
                                    mclMtimes(_mxarray3_, mclVa(f, "f")),
                                    _mxarray10_),
                                  _mxarray5_),
                                _mxarray11_),
                              _mxarray3_),
                            mlfLog(
                              mclMrdivide(
                                mclVv(dI2k, "dI2k"), mclVv(dI1k, "dI1k")))));
                        mclIntArrayAssign2(
                          &Zp, mclMtimes(_mxarray2_, mclVv(X, "X")), v_, v_0);
                        if (v_0 == e_0) {
                            break;
                        }
                        ++v_0;
                    }
                    mlfAssign(&columna, mlfScalar(v_0));
                }
                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, _mxarray8_);
        } 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),
                            _mxarray5_),
                          _mxarray12_)),
                      mclMtimes(
                        _mxarray2_,
                        mlfSin(
                          mclMrdivide(
                            mclMtimes(
                              mclIntArrayRef2(
                                mclVa(coordcond, "coordcond"), v_, 4),
                              _mxarray5_),
                            _mxarray12_))))),
                  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", "matrices1lazo");
    mclValidateOutput(*mislazos, 2, nargout_, "mislazos", "matrices1lazo");
    mxDestroyArray(numero);
    mxDestroyArray(R);
    mxDestroyArray(rgm);
    mxDestroyArray(Xc1);
    mxDestroyArray(d12);
    mxDestroyArray(Z11);
    mxDestroyArray(Z);
    mxDestroyArray(t);
    mxDestroyArray(Xc2);
    mxDestroyArray(Xc3);
    mxDestroyArray(d23);
    mxDestroyArray(d13);
    mxDestroyArray(Z12);
    mxDestroyArray(Z13);
    mxDestroyArray(Z23);
    mxDestroyArray(Z22);
    mxDestroyArray(Z33);
    mxDestroyArray(Z11L);
    mxDestroyArray(Z22L);
    mxDestroyArray(Z12L);
    mxDestroyArray(d14);
    mxDestroyArray(d34);
    mxDestroyArray(d24);
    mxDestroyArray(m);
    mxDestroyArray(n);
    mxDestroyArray(fila);
    mxDestroyArray(columna);
    mxDestroyArray(dI2k);
    mxDestroyArray(dI1k);
    mxDestroyArray(X);
    mxDestroyArray(Zp);
    mxDestroyArray(y);
    mxDestroyArray(Ip);
    mxDestroyArray(ans);
    mxDestroyArray(coordcond);
    mxDestroyArray(coordlazos);
    mxDestroyArray(f);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return Ilazos;
    /*
     * 
     */
}
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es">
	<head>
            <title>e-REdING. Biblioteca de la Escuela Superior de Ingenieros de Sevilla.</title>

                <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<meta name="description" content="Buscador de proyectos ETSI" />
<meta name="author" content="Daniel Callejo"/>
<meta name="author" content="Federico L&oacute;pez"/>
<meta name="author" content="Juli&aacute;n P&eacute;rez"/>
<meta name="author" content="Jos&eacute; Mar&iacute;a Vidal Vidal"/>
<base href="/bibing/proyectos/" /><link rel="shortcut icon" href="./favicon.ico" />
<link rel="stylesheet" href="./publico/css/estructura.css" type="text/css" />
<link rel="stylesheet" href="./publico/css/bootstrap.css" type="text/css" media="screen"/>
<link rel="stylesheet" href="./publico/css/enlaces-capas.css" type="text/css"  />
<link rel="stylesheet" href="./publico/css/pestanas.css" type="text/css"  /> 
<link rel="stylesheet" href="./publico/css/formularios.css" type="text/css" />
<link rel="stylesheet" href="./publico/css/lightbox.css" type="text/css"  />
<link rel="stylesheet" href="./publico/css/autocompleter.css" type="text/css"  />
<link rel="stylesheet" href="./publico/css/resultados.css" type="text/css"  />
<link rel="stylesheet" href="./publico/css/milista.css" type="text/css"  />
<link rel="stylesheet" href="./publico/css/explorador.css" type="text/css"  />
<link rel="stylesheet" href="./publico/css/ultimos.css" type="text/css"  />
<link rel="stylesheet" href="./publico/css/contactar.css" type="text/css"  />
<!-- <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" /> -->
<script src="./publico/javascript/jquery-1.9.1.min.js" type="text/javascript"></script>
<script src="./publico/javascript/bootstrap.js" type="text/javascript"></script>

<script src="./publico/javascript/mootools-1.2.4-core.js" type="text/javascript"></script>
<script src="./publico/javascript/mootools-1-1.2.4.2-more.js" type="text/javascript"></script>
<script src="./publico/javascript/targetbl.js" type="text/javascript"></script>
<script src="./publico/javascript/mensajes.js" type="text/javascript"></script>
<script src="./publico/javascript/form.js" type="text/javascript"></script>
<script src="./publico/javascript/autocompleter/Observer.js" type="text/javascript"></script>
<script src="./publico/javascript/autocompleter/Autocompleter.js" type="text/javascript"></script>
<script src="./publico/javascript/autocompleter/Autocompleter.Request.js" type="text/javascript"></script>
<script src="./publico/javascript/domready.js" type="text/javascript"></script>

<!-- Google tag (gtag.js) -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-8T1TSNC1QY"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'G-8T1TSNC1QY');
</script>



<script type="text/javascript">
function seleccionar_todo(){
   for (i=0;i<document.formulario_marcados.elements.length;i++)
      if(document.formulario_marcados.elements[i].type == "checkbox")
         document.formulario_marcados.elements[i].checked=1
}
function deseleccionar_todo(){
   for (i=0;i<document.formulario_marcados.elements.length;i++)
      if(document.formulario_marcados.elements[i].type == "checkbox")
         document.formulario_marcados.elements[i].checked=0
} 
</script>
	</head>
    <body style="min-width: 960px; background-color: #e2e2e2; height: 100%">	
		<a name="arriba"></a>
<div>
<div id="header">
    <table id="Tabla_01" height="105" border="0" cellpadding="0" cellspacing="0">
    <tr>
        <td>
            <img src="./publico/imagenes/cabecera/banner_new2_01.jpg" width="3" height="105" alt="">
        </td>
        <td>
            <img src="./publico/imagenes/cabecera/banner_new2_02.jpg" width="100" height="105" alt="">
        </td>
        <td width="100%" align="right"  style="min-width: 613px; background-repeat: no-repeat; background-position: top right; font-size: medium; font-weight: bold; color: white;">
            <table width="100%" height="105" border="0">
                <tr>
                    <td style=" vertical-align: top; width: 547px">
                        <!-- <a style="text-decoration: none" href="./"><img src="./publico/imagenes/cabecera/banner_new2_03.jpg"alt=""></a> -->
                        <a style="text-decoration: none" href="/bibing/proyectos/"><img src="./publico/imagenes/cabecera/banner_new2_03.jpg"alt=""></a>
                     </td>
                     <td  background="./publico/imagenes/cabecera/banner_new2_04.jpg" style="background-repeat: no-repeat; background-color: #c6d4e8;"><br><br><br>
                         &nbsp;
                        </td>
                    </tr>
             </table>
        </td>
    </tr>
    <tr style="border-top: 1px solid #ffffff;">
        <td colspan="3" id="menu_sup" style="font-size: small; text-align: right; background-color: #9c1f2f; vertical-align: bottom">
             
					<a href="/bibing/proyectos/" class="enlace " style=" color: #ffffff">Inicio&nbsp;&nbsp;|</a>
					<a href="/bibing/proyectos/acerca/" style=" color: #ffffff" class="enlace ">&nbsp;&nbsp;Acerca de&nbsp;&nbsp;|</a>
					
					<a href="/bibing/proyectos/contactar/" style=" color: #ffffff" class="enlace ">&nbsp;&nbsp;Contactar&nbsp;&nbsp;</a>
			 <!--       <a href="/bibing/proyectos/ayuda/" style=" color: #ffffff" class="enlace  ">&nbsp;&nbsp;Ayuda&nbsp;&nbsp;|</a> -->
					<!-- <form id="idioma" class=""  method="post" action="">
					<div class="inline" style="color: white">
					<input type="submit" class="tipo_letra " style=" color: #ffffff"name="idioma" value="Castellanossss" />&nbsp;&nbsp;
					</div>	
					</form> -->
			        </td>

    </tr>
    </table>
</div>
<br><br>
<div class="colmask rightmenu">
<div class="panel panel-default" style="margin:20px">
            <div class="panel-heading"><h4>PROGRAMA DE DISEÑO DE LAZOS ACTIVOS/PASIVOS PARA AMORTIGUAMIENTO DEL CAMPO MAGNÉTICO EN LÍNEAS ELÉCTRICAS AÉREAS DE ALTA TENSIÓN</h4><h5 style="color:grey"><span class="glyphicon glyphicon-user""></span> : <b>CASAS PÉREZ, JOSÉ EDUARDO DE LAS</b><br><span class="glyphicon glyphicon-book""></span>  :<b> Ingenier&iacute;a Industrial</b></h5></div><div class="panel-body"><div class="contenido_proyecto"><div class="titulo2_explorador">Contenido del proyecto:</div><div class="ruta"><a href="abreproy/3941">Directorio ra&iacute;z</a>&nbsp;&nbsp;>&nbsp;&nbsp;<a href="abreproy/3941/direccion/Programa%252F">Programa</a>&nbsp;&nbsp;>&nbsp;&nbsp;<a href="abreproy/3941/direccion/Programa%252FCodigo%252F">Codigo</a>&nbsp;&nbsp;>&nbsp;&nbsp;<a href="abreproy/3941/direccion/Programa%252FCodigo%252Fcalculos%252F">calculos</a>&nbsp;&nbsp;>&nbsp;&nbsp;<a href="abreproy/3941/direccion/Programa%252FCodigo%252Fcalculos%252Fmatrices1lazo.c%252F">matrices1lazo.c</a></div><div class="listing"></div></div></div></div>
</div>
</div>

        
	</body>
 
 
<!-- Inicio Google Analytics -->
<!--
	<script type="text/javascript">
		var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
		document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
	</script>
	
	<script type="text/javascript">
		try {
		var pageTracker = _gat._getTracker("UA-7789620-1");
		pageTracker._trackPageview();
	} 
		catch(err) {}
	</script>
-->
<!-- Fin Google Analytics -->

</html>