void mexFunction( int nlhs_, Matrix *plhs_[], int nrhs_, Matrix *prhs_[] ) { int ci_, i_, j_; unsigned flags_; Matrix *Mplhs_[32], *Mprhs_[32]; /***************** Compiler Assumptions **************** * * QuadInt_Ave <function being defined> * R0_ real scalar temporary * R1_ real scalar temporary * a real vector/matrix * b real vector/matrix * c real vector/matrix * m1 real vector/matrix * m2 real vector/matrix * m21 real vector/matrix * m22 real vector/matrix * m23 real vector/matrix * m3 real vector/matrix * nargin <function> * option real vector/matrix * strcmp <function> *******************************************************/ Matrix m21; Matrix m22; Matrix m23; Matrix a; Matrix b; Matrix c; Matrix m1; Matrix m2; Matrix m3; Matrix option; double R0_; double R1_; mccRealInit(m1); mccImport(&m1, ((nrhs_>0) ? prhs_[0] : 0), 0, 0); mccRealInit(m2); mccImport(&m2, ((nrhs_>1) ? prhs_[1] : 0), 0, 0); mccRealInit(m3); mccImport(&m3, ((nrhs_>2) ? prhs_[2] : 0), 0, 0); mccRealInit(option); mccImport(&option, ((nrhs_>3) ? prhs_[3] : 0), 0, 0); mccRealInit(m21); mccRealInit(m22); mccRealInit(m23); mccRealInit(a); mccRealInit(b); mccRealInit(c); /* % QuadInt_Ave -- Quadratic Interpolation given cell-averages */ /* % Usage */ /* % [m21,m22,m23, a,b,c] = QuadInt_Ave(m1, m2, m3) */ /* % Inputs */ /* % m1,m2,m3 averages of the desired quadratic polynomial on */ /* % [0,1], [1,2] and [2,3] respectively */ /* % option interval to impute to: */ /* % default, impute to [1,2] */ /* % option='Left' => impute to [0,1] */ /* % option='Right => impute to [2,3] */ /* % Outputs */ /* % m21,m22,m23 averages of the computed quadratic polynomial on */ /* % [1,4/3], [4/3,5/3], [5/3,2] respectively */ /* % a, b, c coef. of the interpolating quadratic polynomial, */ /* % p(x) = a + bx + cx^2, */ /* % Ave{p(x) | [0,1]} = m1, */ /* % Ave{p(x) | [1,2]} = m2, and */ /* % Ave{p(x) | [2,3]} = m3. */ /* a = 11/6*m1 - 7/6*m2 + m3/3; */ R0_ = (11 / (double) 6); if( m1.flags & mccNOTSET ) { mexErrMsgTxt( "variable m1 undefined, line 22" ); } R1_ = (7 / (double) 6); if( m2.flags & mccNOTSET ) { mexErrMsgTxt( "variable m2 undefined, line 22" ); } if( m3.flags & mccNOTSET ) { mexErrMsgTxt( "variable m3 undefined, line 22" ); } { int m_=1, n_=1, cx_ = 0; double t_; double *p_a; int I_a=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&a, m_, n_); I_a = (a.m != 1 || a.n != 1); p_a = a.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_a+=I_a, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_a = (((R0_ * *p_m1) - (R1_ * *p_m2)) + (*p_m3 / (double) 3)); ; } } } a.dmode = mxNUMBER; /* b = -2*m1 + 3*m2 - m3; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_b; int I_b=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&b, m_, n_); I_b = (b.m != 1 || b.n != 1); p_b = b.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_b+=I_b, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_b = (((-2 * *p_m1) + (3 * *p_m2)) - *p_m3); ; } } } b.dmode = mxNUMBER; /* c = m1/2 - m2 + m3/2; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_c; int I_c=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&c, m_, n_); I_c = (c.m != 1 || c.n != 1); p_c = c.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_c+=I_c, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_c = (((*p_m1 / (double) 2) - *p_m2) + (*p_m3 / (double) 2)); ; } } } c.dmode = mxNUMBER; /* if nargin==3, */ if ((mccNargin() == 3)) { /* m21 = (5*m1 + 26*m2 -4*m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m21; int I_m21=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m21, m_, n_); I_m21 = (m21.m != 1 || m21.n != 1); p_m21 = m21.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m21+=I_m21, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m21 = ((((5 * *p_m1) + (26 * *p_m2)) - (4 * *p_m3)) / (double) 27); ; } } } m21.dmode = mxNUMBER; /* m22 = (-m1 + 29*m2 - m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m22; int I_m22=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m22, m_, n_); I_m22 = (m22.m != 1 || m22.n != 1); p_m22 = m22.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m22+=I_m22, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m22 = ((((-*p_m1) + (29 * *p_m2)) - *p_m3) / (double) 27); ; } } } m22.dmode = mxNUMBER; /* m23 = (-4*m1 + 26*m2 +5*m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m23; int I_m23=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m23, m_, n_); I_m23 = (m23.m != 1 || m23.n != 1); p_m23 = m23.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m23+=I_m23, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m23 = ((((-4 * *p_m1) + (26 * *p_m2)) + (5 * *p_m3)) / (double) 27); ; } } } m23.dmode = mxNUMBER; /* elseif strcmp(option,'Left') */ } else { if ((double)mccStrcmp(&option, &S0_)) { /* m21 = (41*m1 - 19*m2 + 5*m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m21; int I_m21=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m21, m_, n_); I_m21 = (m21.m != 1 || m21.n != 1); p_m21 = m21.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m21+=I_m21, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m21 = ((((41 * *p_m1) - (19 * *p_m2)) + (5 * *p_m3)) / (double) 27); ; } } } m21.dmode = mxNUMBER; /* m22 = (26*m1 + 2*m2 - m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m22; int I_m22=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m22, m_, n_); I_m22 = (m22.m != 1 || m22.n != 1); p_m22 = m22.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m22+=I_m22, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m22 = ((((26 * *p_m1) + (2 * *p_m2)) - *p_m3) / (double) 27); ; } } } m22.dmode = mxNUMBER; /* m23 = (14*m1 + 17*m2 - 4*m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m23; int I_m23=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m23, m_, n_); I_m23 = (m23.m != 1 || m23.n != 1); p_m23 = m23.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m23+=I_m23, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m23 = ((((14 * *p_m1) + (17 * *p_m2)) - (4 * *p_m3)) / (double) 27); ; } } } m23.dmode = mxNUMBER; /* elseif strcmp(option,'Right') */ } else { if ((double)mccStrcmp(&option, &S1_)) { /* m21 = (-4*m1 + 17*m2 + 14*m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m21; int I_m21=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m21, m_, n_); I_m21 = (m21.m != 1 || m21.n != 1); p_m21 = m21.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m21+=I_m21, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m21 = ((((-4 * *p_m1) + (17 * *p_m2)) + (14 * *p_m3)) / (double) 27); ; } } } m21.dmode = mxNUMBER; /* m22 = (-m1 + 2*m2 + 26*m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m22; int I_m22=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m22, m_, n_); I_m22 = (m22.m != 1 || m22.n != 1); p_m22 = m22.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m22+=I_m22, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m22 = ((((-*p_m1) + (2 * *p_m2)) + (26 * *p_m3)) / (double) 27); ; } } } m22.dmode = mxNUMBER; /* m23 = (5*m1 - 19*m2 + 41*m3)/27; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_m23; int I_m23=1; double *p_m1; int I_m1=1; double *p_m2; int I_m2=1; double *p_m3; int I_m3=1; m_ = mcmCalcResultSize(m_, &n_, m1.m, m1.n); m_ = mcmCalcResultSize(m_, &n_, m2.m, m2.n); m_ = mcmCalcResultSize(m_, &n_, m3.m, m3.n); mccAllocateMatrix(&m23, m_, n_); I_m23 = (m23.m != 1 || m23.n != 1); p_m23 = m23.pr; I_m1 = (m1.m != 1 || m1.n != 1); p_m1 = m1.pr; I_m2 = (m2.m != 1 || m2.n != 1); p_m2 = m2.pr; I_m3 = (m3.m != 1 || m3.n != 1); p_m3 = m3.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_m23+=I_m23, p_m1+=I_m1, p_m2+=I_m2, p_m3+=I_m3) { *p_m23 = ((((5 * *p_m1) - (19 * *p_m2)) + (41 * *p_m3)) / (double) 27); ; } } } m23.dmode = mxNUMBER; /* end */ } } } /* % Copyright (c) 1995-6. David L. Donoho and Thomas P.Y.Yu */ mccReturnFirstValue(&plhs_[0], &m21); mccReturnValue(&plhs_[1], &m22); mccReturnValue(&plhs_[2], &m23); mccReturnValue(&plhs_[3], &a); mccReturnValue(&plhs_[4], &b); mccReturnValue(&plhs_[5], &c); return; }
void mexFunction( int nlhs_, Matrix *plhs_[], int nrhs_, Matrix *prhs_[] ) { int ci_, i_, j_; unsigned flags_; Matrix *Mplhs_[32], *Mprhs_[32]; /***************** Compiler Assumptions **************** * * CumProb real vector/matrix * Indexs real vector/matrix * Prob real vector/matrix * R0_ real scalar temporary * RM0_ real vector/matrix temporary * RM1_ real vector/matrix temporary * SMALL real scalar * Size real vector/matrix * XData real vector/matrix * XSet real vector/matrix * YData real vector/matrix * YSet real vector/matrix * abs <function> * any <function> * bootstrap <function being defined> * ceil <function> * eps <function> * error <function> * i integer scalar * j integer scalar * nargin <function> * rand <function> * realization real vector/matrix * samples integer scalar * size <function> * sum <function> * uniform integer scalar * zeros <function> *******************************************************/ Matrix XSet; Matrix YSet; Matrix Indexs; Matrix XData; Matrix YData; Matrix Prob; Matrix Size; double SMALL; int samples; int uniform; Matrix CumProb; int i; Matrix realization; int j; Matrix RM0_; double R0_; Matrix RM1_; mccRealInit(XData); mccImport(&XData, ((nrhs_>0) ? prhs_[0] : 0), 0, 0); mccRealInit(YData); mccImport(&YData, ((nrhs_>1) ? prhs_[1] : 0), 0, 0); mccRealInit(Prob); mccImportCopy(&Prob, ((nrhs_>2) ? prhs_[2] : 0), 0, 0); mccRealInit(Size); mccImportCopy(&Size, ((nrhs_>3) ? prhs_[3] : 0), 0, 0); mccRealInit(XSet); mccRealInit(YSet); mccRealInit(Indexs); mccRealInit(CumProb); mccRealInit(realization); mccRealInit(RM0_); mccRealInit(RM1_); /* % [XSet, YSet, Indexs]=bootstrap(XData, YData, */ /* % Prob=ones(1,size(XData), Size=size(XData,2)) */ /* % Creates a bootstrap-samples-set of size 'Size' */ /* % #realonly */ /* % #inbounds */ /* SMALL=1e4*eps ; */ SMALL = (1e4 * mcmEps()); /* % save the count of samples */ /* samples=size(XData,2) ; */ samples = mccGetDimensionSize(&XData, 2); /* % verify this */ /* if samples~=size(YData,2), */ if ((samples != mccGetDimensionSize(&YData, 2))) { /* error('different count of samples in XData and YData') ; */ mccError(&S0_); /* end ; */ } /* % handle default parameters */ /* if nargin<2, */ if ((mccNargin() < 2)) { /* % not enough parameters */ /* error('not enough parameters') ; */ mccError(&S1_); /* end ; */ } /* if nargin<3, */ if ((mccNargin() < 3)) { /* % uniform distribution */ /* % Prob=ones(1, samples)./samples ; */ /* uniform=1 ; */ uniform = 1; /* else */ } else { /* % normalize the give distribution */ /* Prob=Prob./(sum(Prob)+eps) ; */ mccSum(&RM0_, &Prob); R0_ = mcmEps(); { int m_=1, n_=1, cx_ = 0; double t_; double *p_Prob; int I_Prob=1; double *p_1Prob; int I_1Prob=1; double *p_RM0_; int I_RM0_=1; m_ = mcmCalcResultSize(m_, &n_, Prob.m, Prob.n); m_ = mcmCalcResultSize(m_, &n_, RM0_.m, RM0_.n); mccAllocateMatrix(&Prob, m_, n_); I_Prob = (Prob.m != 1 || Prob.n != 1); p_Prob = Prob.pr; I_1Prob = (Prob.m != 1 || Prob.n != 1); p_1Prob = Prob.pr; I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_Prob+=I_Prob, p_1Prob+=I_1Prob, p_RM0_+=I_RM0_) { *p_Prob = (*p_1Prob / (double) (*p_RM0_ + R0_)); ; } } } Prob.dmode = mxNUMBER; /* if any( Prob - 1/samples > 1e-8 ), */ R0_ = (1 / (double) samples); RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_Prob; int I_Prob=1; m_ = mcmCalcResultSize(m_, &n_, Prob.m, Prob.n); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; I_Prob = (Prob.m != 1 || Prob.n != 1); p_Prob = Prob.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_Prob+=I_Prob) { *p_RM0_ = ((*p_Prob - R0_) > 1e-8); ; } } } RM0_.dmode = mxNUMBER; mccAny(&RM1_, &RM0_); if (mccIfCondition(&RM1_)) { /* uniform=0 ; */ uniform = 0; /* else */ } else { /* uniform=1 ; */ uniform = 1; /* end ; */ } /* end ; */ } /* if nargin<4, */ if ((mccNargin() < 4)) { /* % the bootstrap size equals the size of the given set defaultly */ /* Size=samples ; */ { double tr_ = samples; mccAllocateMatrix(&Size, 1, 1); *Size.pr = tr_; } Size.dmode = mxNUMBER; /* end ; */ } /* % optimization for uniform distributions */ /* if ~uniform, */ if ((double)(!uniform)) { /* % compute the cumulative propability */ /* CumProb=zeros(1,samples) ; */ mccZerosMN(&CumProb, 1, samples); /* CumProb(1)=Prob(1) ; */ CumProb.pr[(1-1)] = (Prob.pr[(1-1)]); CumProb.dmode = mxNUMBER; /* for i=2:samples, */ for (i = 2; i <= samples; i = i + 1) { /* CumProb(i)=CumProb(i-1)+Prob(i) ; */ CumProb.pr[(i-1)] = ((CumProb.pr[((i-1)-1)]) + (Prob.pr[(i-1)])); CumProb.dmode = mxNUMBER; /* end ; */ } /* if abs(CumProb(samples)-1)>SMALL, */ if ((fabs(((CumProb.pr[(samples-1)]) - 1)) > SMALL)) { /* % CumProb(samples)-1 */ /* error('round-off-problem') ; */ mccError(&S2_); /* end ; */ } /* end ; */ } /* % not fast, but it works */ /* realization=rand(1,Size) ; */ Mprhs_[0] = mccTempMatrix((double)(1), 0., mxNUMBER); Mprhs_[1] = &Size; Mplhs_[0] = &realization; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "rand", 58); /* if uniform, */ if ((double)uniform) { /* Indexs=ceil(samples*realization) ; */ RM1_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM1_; int I_RM1_=1; double *p_realization; int I_realization=1; m_ = mcmCalcResultSize(m_, &n_, realization.m, realization.n); mccAllocateMatrix(&RM1_, m_, n_); I_RM1_ = (RM1_.m != 1 || RM1_.n != 1); p_RM1_ = RM1_.pr; I_realization = (realization.m != 1 || realization.n != 1); p_realization = realization.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM1_+=I_RM1_, p_realization+=I_realization) { *p_RM1_ = (samples * *p_realization); ; } } } RM1_.dmode = mxNUMBER; mccCeil(&Indexs, &RM1_); /* else */ } else { /* Indexs=zeros(1,Size) ; */ mccZerosMN(&Indexs, 1, ((int)*Size.pr)); /* for j=1:Size, */ for (j = 1; j <= *Size.pr; j = j + 1) { /* Indexs(j)=sum(CumProb<=realization(j)) + 1 ; */ R0_ = (realization.pr[(j-1)]); RM1_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM1_; int I_RM1_=1; double *p_CumProb; int I_CumProb=1; m_ = mcmCalcResultSize(m_, &n_, CumProb.m, CumProb.n); mccAllocateMatrix(&RM1_, m_, n_); I_RM1_ = (RM1_.m != 1 || RM1_.n != 1); p_RM1_ = RM1_.pr; I_CumProb = (CumProb.m != 1 || CumProb.n != 1); p_CumProb = CumProb.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM1_+=I_RM1_, p_CumProb+=I_CumProb) { *p_RM1_ = (*p_CumProb <= R0_); ; } } } RM1_.dmode = mxNUMBER; Indexs.pr[(j-1)] = (IntRealVectorSum(&RM1_) + 1); Indexs.dmode = mxNUMBER; /* end ; */ } /* end ; */ } /* XSet=XData(:, Indexs) ; */ mccFindRowIndex(&RM1_, &Indexs, &XData); { int m_=1, n_=1, cx_ = 0; double t_; double *p_XSet; int I_XSet=1; double *p_XData; int I_XData=1; double *p_RM1_; int I_RM1_=1; m_ = mcmCalcResultSize(m_, &n_, XData.m, (RM1_.m * RM1_.n)); mccAllocateMatrix(&XSet, m_, n_); I_XSet = (XSet.m != 1 || XSet.n != 1); p_XSet = XSet.pr; I_RM1_ = (RM1_.m != 1 || RM1_.n != 1); p_RM1_ = RM1_.pr; for (j_=0; j_<n_; ++j_, p_RM1_ += I_RM1_) { p_XData = XData.pr + XData.m * ((int)(*p_RM1_ - .5)) + 0; for (i_=0; i_<m_; ++i_, p_XSet+=I_XSet, p_XData+=I_XData) { *p_XSet = *p_XData; ; } } } XSet.dmode = XData.dmode; /* YSet=YData(:, Indexs) ; */ mccFindRowIndex(&RM1_, &Indexs, &YData); { int m_=1, n_=1, cx_ = 0; double t_; double *p_YSet; int I_YSet=1; double *p_YData; int I_YData=1; double *p_RM1_; int I_RM1_=1; m_ = mcmCalcResultSize(m_, &n_, YData.m, (RM1_.m * RM1_.n)); mccAllocateMatrix(&YSet, m_, n_); I_YSet = (YSet.m != 1 || YSet.n != 1); p_YSet = YSet.pr; I_RM1_ = (RM1_.m != 1 || RM1_.n != 1); p_RM1_ = RM1_.pr; for (j_=0; j_<n_; ++j_, p_RM1_ += I_RM1_) { p_YData = YData.pr + YData.m * ((int)(*p_RM1_ - .5)) + 0; for (i_=0; i_<m_; ++i_, p_YSet+=I_YSet, p_YData+=I_YData) { *p_YSet = *p_YData; ; } } } YSet.dmode = YData.dmode; mccReturnFirstValue(&plhs_[0], &XSet); mccReturnValue(&plhs_[1], &YSet); mccReturnValue(&plhs_[2], &Indexs); return; }
void mexFunction( int nlhs_, Matrix *plhs_[], int nrhs_, Matrix *prhs_[] ) { int ci_, i_, j_; unsigned flags_; Matrix *Mplhs_[32], *Mprhs_[32]; /***************** Compiler Assumptions **************** * * C real vector/matrix * D real vector/matrix * DR real vector/matrix * H real vector/matrix * I0_ integer scalar temporary * IR real vector/matrix * Inp real vector/matrix * R real vector/matrix * R0_ real scalar temporary * RM0_ real vector/matrix temporary * RM1_ real vector/matrix temporary * RM2_ real vector/matrix temporary * SCALING_TYPE integer scalar * X real vector/matrix * bias integer scalar * design <function being defined> * diagProd <function> * dupCol <function> * error <function> * exp <function> * h real vector/matrix * inv <function> * j integer scalar * m integer scalar * n integer scalar * n1 integer scalar * nargin <function> * ones <function> * option real vector/matrix * options real vector/matrix * p integer scalar * rc integer scalar * realsqrt <function> * rr integer scalar * s real vector/matrix * size <function> * type integer scalar * zeros <function> *******************************************************/ Matrix H; Matrix Inp; Matrix X; Matrix C; Matrix R; Matrix options; int type; int bias; Matrix option; int n; int p; int n1; int m; int rr; int rc; int SCALING_TYPE; Matrix IR; int j; Matrix D; Matrix s; Matrix DR; Matrix h; int I0_; Matrix RM0_; Matrix RM1_; Matrix RM2_; double R0_; mccRealInit(X); mccImport(&X, ((nrhs_>0) ? prhs_[0] : 0), 0, 0); mccRealInit(C); mccImport(&C, ((nrhs_>1) ? prhs_[1] : 0), 0, 0); mccRealInit(R); mccImportCopy(&R, ((nrhs_>2) ? prhs_[2] : 0), 0, 0); mccRealInit(options); mccImport(&options, ((nrhs_>3) ? prhs_[3] : 0), 0, 0); mccRealInit(H); mccRealInit(Inp); mccRealInit(option); mccRealInit(IR); mccRealInit(D); mccRealInit(s); mccRealInit(DR); mccRealInit(h); mccRealInit(RM0_); mccRealInit(RM1_); mccRealInit(RM2_); /* % [H, Inp] = Design(X, C, R, options) */ /* % Gets the design matrix from the input data, centre positions */ /* % and radii factors. */ /* % Input */ /* % X Input training data (n-by-p) */ /* % C List of centres (n-by-m) */ /* % R Scale factors: scalar, n-vector, or n-by-n matrix */ /* % opt Specifying basis function type ('g' for Gaussian, */ /* % 'c' for Cauchy) and whether bias unit is rquired */ /* % (if yes then 'b'). */ /* % Output */ /* % H Design matrix (p-by-m) */ /* % Inp p-by-m Matrix of the Norms ... (only for R=nvector) */ /* % default function type */ /* % 'g' = gaussian (0) */ /* % 'c' = cauchy (1) */ /* % 'm' = multiquadric (2) */ /* % 'i' = inverse multiquadric (3) */ /* type = 0; */ type = 0; /* % default bias */ /* bias = 0; */ bias = 0; /* % process options */ /* if nargin > 3 */ if ((mccNargin() > 3)) { /* for option = options */ for (I0_ = 0; I0_ < options.n; ++I0_) { mccForCol(&option, &options, I0_); /* if option == 'g' */ RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_option; int I_option=1; m_ = mcmCalcResultSize(m_, &n_, option.m, option.n); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; I_option = (option.m != 1 || option.n != 1); p_option = option.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_option+=I_option) { *p_RM0_ = (*p_option == 'g'); ; } } } RM0_.dmode = mxNUMBER; if (mccIfCondition(&RM0_)) { /* type = 0; */ type = 0; /* elseif option == 'c' */ } else { RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_option; int I_option=1; m_ = mcmCalcResultSize(m_, &n_, option.m, option.n); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; I_option = (option.m != 1 || option.n != 1); p_option = option.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_option+=I_option) { *p_RM0_ = (*p_option == 'c'); ; } } } RM0_.dmode = mxNUMBER; if (mccIfCondition(&RM0_)) { /* type = 1; */ type = 1; /* elseif option == 'm' */ } else { RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_option; int I_option=1; m_ = mcmCalcResultSize(m_, &n_, option.m, option.n); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; I_option = (option.m != 1 || option.n != 1); p_option = option.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_option+=I_option) { *p_RM0_ = (*p_option == 'm'); ; } } } RM0_.dmode = mxNUMBER; if (mccIfCondition(&RM0_)) { /* type = 2; */ type = 2; /* elseif option == 'i' */ } else { RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_option; int I_option=1; m_ = mcmCalcResultSize(m_, &n_, option.m, option.n); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; I_option = (option.m != 1 || option.n != 1); p_option = option.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_option+=I_option) { *p_RM0_ = (*p_option == 'i'); ; } } } RM0_.dmode = mxNUMBER; if (mccIfCondition(&RM0_)) { /* type = 3; */ type = 3; /* elseif option == 'b' */ } else { RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_option; int I_option=1; m_ = mcmCalcResultSize(m_, &n_, option.m, option.n); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; I_option = (option.m != 1 || option.n != 1); p_option = option.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_option+=I_option) { *p_RM0_ = (*p_option == 'b'); ; } } } RM0_.dmode = mxNUMBER; if (mccIfCondition(&RM0_)) { /* bias = 1; */ bias = 1; /* else */ } else { /* error('rbfDesign: illegal option') */ mccError(&S0_); /* end */ } } } } } /* end */ } /* end */ } /* % preliminary sizing */ /* [n, p] = size(X); */ mccGetMatrixSize(&n,&p, &X); /* [n1, m] = size(C); */ mccGetMatrixSize(&n1,&m, &C); /* if n ~= n1 */ if ((n != n1)) { /* error('rbfDesign: mismatched X, C') */ mccError(&S1_); /* end */ } /* [rr, rc] = size(R); */ mccGetMatrixSize(&rr,&rc, &R); /* % determine scaling type */ /* if rr == 1 & rc == 1 */ if ((double)(!!(rr == 1) && !!(rc == 1))) { /* SCALING_TYPE = 1; % same radius for each centre */ SCALING_TYPE = 1; /* elseif rr == 1 */ } else { if ((rr == 1)) { /* if rc == n */ if ((rc == n)) { /* SCALING_TYPE = 2; % same diagonal metric for each centre */ SCALING_TYPE = 2; /* R = R'; */ mccConjTrans(&R, &R); /* elseif rc == m */ } else { if ((rc == m)) { /* SCALING_TYPE = 4; % different radius for each centre */ SCALING_TYPE = 4; /* R = R'; */ mccConjTrans(&R, &R); /* else */ } else { /* error('rbfDesign: mismatched C and row vector R') */ mccError(&S2_); /* end */ } } /* elseif rc == 1 */ } else { if ((rc == 1)) { /* if rr == n */ if ((rr == n)) { /* SCALING_TYPE = 2; % same diagonal metric for each centre */ SCALING_TYPE = 2; /* elseif rr == m */ } else { if ((rr == m)) { /* SCALING_TYPE = 4; % different radius for each centre */ SCALING_TYPE = 4; /* else */ } else { /* error('rbfDesign: mismatched C and row vector R') */ mccError(&S3_); /* end */ } } /* elseif rr == n */ } else { if ((rr == n)) { /* if rc == n */ if ((rc == n)) { /* SCALING_TYPE = 3; % same metric for each centre */ SCALING_TYPE = 3; /* IR = inv(R); */ Mprhs_[0] = &R; Mplhs_[0] = &IR; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "inv", 84); /* elseif rc == m */ } else { if ((rc == m)) { /* SCALING_TYPE = 5; % different diagonal metric for each centre */ SCALING_TYPE = 5; /* else */ } else { /* error('rbfDesign: mismatched C and matrix R') */ mccError(&S4_); /* end */ } } /* elseif rc == n */ } else { if ((rc == n)) { /* if rr == m */ if ((rr == m)) { /* SCALING_TYPE = 5; % different diagonal metric for each centre */ SCALING_TYPE = 5; /* R = R'; */ mccConjTrans(&R, &R); /* else */ } else { /* error('rbfDesign: mismatched C and matrix R') */ mccError(&S5_); /* end */ } /* else */ } else { /* error('rbfDesign: wrong sized R') */ mccError(&S6_); /* end */ } } } } } /* % start constructing H */ /* H = zeros(p, m); */ mccZerosMN(&H, p, m); /* Inp = H ; */ mccCopy(&Inp, &H); /* for j = 1:m */ for (j = 1; j <= m; j = j + 1) { /* % get p difference vectors for this centre */ /* D = X - dupCol( C(: , j) , p) ; */ RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_C; int I_C=1, J_C; m_ = mcmCalcResultSize(m_, &n_, C.m, 1); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; if (C.m == 1 && C.n == 1) { I_C = J_C = 0; } else { I_C=1; J_C=C.m-m_; } p_C = C.pr + 0 + C.m * (j-1); for (j_=0; j_<n_; ++j_, p_C += J_C) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_C+=I_C) { *p_RM0_ = *p_C; ; } } } RM0_.dmode = C.dmode; Mprhs_[0] = &RM0_; Mprhs_[1] = mccTempMatrix((double)(p), 0., mxNUMBER); Mplhs_[0] = &RM1_; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "dupCol", 106); { int m_=1, n_=1, cx_ = 0; double t_; double *p_D; int I_D=1; double *p_X; int I_X=1; double *p_RM1_; int I_RM1_=1; m_ = mcmCalcResultSize(m_, &n_, X.m, X.n); m_ = mcmCalcResultSize(m_, &n_, RM1_.m, RM1_.n); mccAllocateMatrix(&D, m_, n_); I_D = (D.m != 1 || D.n != 1); p_D = D.pr; I_X = (X.m != 1 || X.n != 1); p_X = X.pr; I_RM1_ = (RM1_.m != 1 || RM1_.n != 1); p_RM1_ = RM1_.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_D+=I_D, p_X+=I_X, p_RM1_+=I_RM1_) { *p_D = (*p_X - *p_RM1_); ; } } } D.dmode = mxNUMBER; /* % do metric calculation */ /* if SCALING_TYPE == 1 % same radius for each centre */ if ((SCALING_TYPE == 1)) { /* s = diagProd ( D' , D ) / R^2 ; */ mccConjTrans(&RM1_, &D); Mprhs_[0] = &RM1_; Mprhs_[1] = &D; Mplhs_[0] = &RM0_; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "diagProd", 110); mccPower(&RM2_, &R, mccTempMatrix((double)(2), 0., mxNUMBER)); mccRealRightDivide(&s, &RM0_, &RM2_); /* elseif SCALING_TYPE == 2 % same diagonal metric for each centre */ } else { if ((SCALING_TYPE == 2)) { /* DR = D ./ dupCol(R, p); */ Mprhs_[0] = &R; Mprhs_[1] = mccTempMatrix((double)(p), 0., mxNUMBER); Mplhs_[0] = &RM2_; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "dupCol", 112); { int m_=1, n_=1, cx_ = 0; double t_; double *p_DR; int I_DR=1; double *p_D; int I_D=1; double *p_RM2_; int I_RM2_=1; m_ = mcmCalcResultSize(m_, &n_, D.m, D.n); m_ = mcmCalcResultSize(m_, &n_, RM2_.m, RM2_.n); mccAllocateMatrix(&DR, m_, n_); I_DR = (DR.m != 1 || DR.n != 1); p_DR = DR.pr; I_D = (D.m != 1 || D.n != 1); p_D = D.pr; I_RM2_ = (RM2_.m != 1 || RM2_.n != 1); p_RM2_ = RM2_.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_DR+=I_DR, p_D+=I_D, p_RM2_+=I_RM2_) { *p_DR = (*p_D / (double) *p_RM2_); ; } } } DR.dmode = mxNUMBER; /* s = diagProd(DR',DR); */ mccConjTrans(&RM2_, &DR); Mprhs_[0] = &RM2_; Mprhs_[1] = &DR; Mplhs_[0] = &s; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "diagProd", 113); /* elseif SCALING_TYPE == 3 % same metric for each centre */ } else { if ((SCALING_TYPE == 3)) { /* DR = IR * D; */ mccRealMatrixMultiply(&DR, &IR, &D); /* s = diagProd(DR',DR); */ mccConjTrans(&RM2_, &DR); Mprhs_[0] = &RM2_; Mprhs_[1] = &DR; Mplhs_[0] = &s; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "diagProd", 116); /* elseif SCALING_TYPE == 4 % different radius for each centre */ } else { if ((SCALING_TYPE == 4)) { /* s = diagProd(D',D) / R(j)^2; */ mccConjTrans(&RM2_, &D); Mprhs_[0] = &RM2_; Mprhs_[1] = &D; Mplhs_[0] = &RM0_; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "diagProd", 118); R0_ = mcmRealPowerInt((R.pr[(j-1)]), 2); { int m_=1, n_=1, cx_ = 0; double t_; double *p_s; int I_s=1; double *p_RM0_; int I_RM0_=1; m_ = mcmCalcResultSize(m_, &n_, RM0_.m, RM0_.n); mccAllocateMatrix(&s, m_, n_); I_s = (s.m != 1 || s.n != 1); p_s = s.pr; I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_s+=I_s, p_RM0_+=I_RM0_) { *p_s = (*p_RM0_ / (double) R0_); ; } } } s.dmode = mxNUMBER; /* Inp(:,j) = s ; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_Inp; int I_Inp=1, J_Inp; double *p_s; int I_s=1; m_ = mcmCalcResultSize(m_, &n_, s.m, s.n); if (Inp.m == 1 && Inp.n == 1) { I_Inp = J_Inp = 0; } else { I_Inp=1; J_Inp=Inp.m-m_; } p_Inp = Inp.pr + 0 + Inp.m * (j-1); I_s = (s.m != 1 || s.n != 1); p_s = s.pr; for (j_=0; j_<n_; ++j_, p_Inp += J_Inp) { for (i_=0; i_<m_; ++i_, p_Inp+=I_Inp, p_s+=I_s) { *p_Inp = *p_s; ; } } } Inp.dmode = mxNUMBER; /* else % different diagonal metric for each centre */ } else { /* DR = D ./ dupCol(R(:,j), p); */ RM0_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM0_; int I_RM0_=1; double *p_R; int I_R=1, J_R; m_ = mcmCalcResultSize(m_, &n_, R.m, 1); mccAllocateMatrix(&RM0_, m_, n_); I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; if (R.m == 1 && R.n == 1) { I_R = J_R = 0; } else { I_R=1; J_R=R.m-m_; } p_R = R.pr + 0 + R.m * (j-1); for (j_=0; j_<n_; ++j_, p_R += J_R) { for (i_=0; i_<m_; ++i_, p_RM0_+=I_RM0_, p_R+=I_R) { *p_RM0_ = *p_R; ; } } } RM0_.dmode = R.dmode; Mprhs_[0] = &RM0_; Mprhs_[1] = mccTempMatrix((double)(p), 0., mxNUMBER); Mplhs_[0] = &RM2_; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "dupCol", 121); { int m_=1, n_=1, cx_ = 0; double t_; double *p_DR; int I_DR=1; double *p_D; int I_D=1; double *p_RM2_; int I_RM2_=1; m_ = mcmCalcResultSize(m_, &n_, D.m, D.n); m_ = mcmCalcResultSize(m_, &n_, RM2_.m, RM2_.n); mccAllocateMatrix(&DR, m_, n_); I_DR = (DR.m != 1 || DR.n != 1); p_DR = DR.pr; I_D = (D.m != 1 || D.n != 1); p_D = D.pr; I_RM2_ = (RM2_.m != 1 || RM2_.n != 1); p_RM2_ = RM2_.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_DR+=I_DR, p_D+=I_D, p_RM2_+=I_RM2_) { *p_DR = (*p_D / (double) *p_RM2_); ; } } } DR.dmode = mxNUMBER; /* s = diagProd(DR',DR); */ mccConjTrans(&RM2_, &DR); Mprhs_[0] = &RM2_; Mprhs_[1] = &DR; Mplhs_[0] = &s; mccCallMATLAB(1, Mplhs_, 2, Mprhs_, "diagProd", 122); /* end */ } } } } /* % apply basis function */ /* if type == 0 % Gaussian (default) */ if ((type == 0)) { /* h = exp(-s); */ RM2_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM2_; int I_RM2_=1; double *p_s; int I_s=1; m_ = mcmCalcResultSize(m_, &n_, s.m, s.n); mccAllocateMatrix(&RM2_, m_, n_); I_RM2_ = (RM2_.m != 1 || RM2_.n != 1); p_RM2_ = RM2_.pr; I_s = (s.m != 1 || s.n != 1); p_s = s.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM2_+=I_RM2_, p_s+=I_s) { *p_RM2_ = (-*p_s); ; } } } RM2_.dmode = mxNUMBER; Mprhs_[0] = &RM2_; Mplhs_[0] = &h; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "exp", 128); /* elseif type == 1 % Cauchy */ } else { if ((type == 1)) { /* h = 1 ./ (s + 1); */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_h; int I_h=1; double *p_s; int I_s=1; m_ = mcmCalcResultSize(m_, &n_, s.m, s.n); mccAllocateMatrix(&h, m_, n_); I_h = (h.m != 1 || h.n != 1); p_h = h.pr; I_s = (s.m != 1 || s.n != 1); p_s = s.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_h+=I_h, p_s+=I_s) { *p_h = (1 / (double) (*p_s + 1)); ; } } } h.dmode = mxNUMBER; /* elseif type == 2 % multiquadric */ } else { if ((type == 2)) { /* h = sqrt(s + 1); */ RM2_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM2_; int I_RM2_=1; double *p_s; int I_s=1; m_ = mcmCalcResultSize(m_, &n_, s.m, s.n); mccAllocateMatrix(&RM2_, m_, n_); I_RM2_ = (RM2_.m != 1 || RM2_.n != 1); p_RM2_ = RM2_.pr; I_s = (s.m != 1 || s.n != 1); p_s = s.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM2_+=I_RM2_, p_s+=I_s) { *p_RM2_ = (*p_s + 1); ; } } } RM2_.dmode = mxNUMBER; Mprhs_[0] = &RM2_; Mplhs_[0] = &h; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "realsqrt", 136); /* elseif type == 3 % inverse multiquadric */ } else { if ((type == 3)) { /* h = 1 ./ sqrt(s + 1); */ RM2_.dmode = mxNUMBER; { int m_=1, n_=1, cx_ = 0; double t_; double *p_RM2_; int I_RM2_=1; double *p_s; int I_s=1; m_ = mcmCalcResultSize(m_, &n_, s.m, s.n); mccAllocateMatrix(&RM2_, m_, n_); I_RM2_ = (RM2_.m != 1 || RM2_.n != 1); p_RM2_ = RM2_.pr; I_s = (s.m != 1 || s.n != 1); p_s = s.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_RM2_+=I_RM2_, p_s+=I_s) { *p_RM2_ = (*p_s + 1); ; } } } RM2_.dmode = mxNUMBER; mccSqrt(&RM0_, &RM2_); { int m_=1, n_=1, cx_ = 0; double t_; double *p_h; int I_h=1; double *p_RM0_; int I_RM0_=1; m_ = mcmCalcResultSize(m_, &n_, RM0_.m, RM0_.n); mccAllocateMatrix(&h, m_, n_); I_h = (h.m != 1 || h.n != 1); p_h = h.pr; I_RM0_ = (RM0_.m != 1 || RM0_.n != 1); p_RM0_ = RM0_.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_h+=I_h, p_RM0_+=I_RM0_) { *p_h = (1 / (double) *p_RM0_); ; } } } h.dmode = mxNUMBER; /* end */ } } } } /* % insert result in H */ /* H(:, j) = h; */ { int m_=1, n_=1, cx_ = 0; double t_; double *p_H; int I_H=1, J_H; double *p_h; int I_h=1; m_ = mcmCalcResultSize(m_, &n_, h.m, h.n); if (H.m == 1 && H.n == 1) { I_H = J_H = 0; } else { I_H=1; J_H=H.m-m_; } p_H = H.pr + 0 + H.m * (j-1); I_h = (h.m != 1 || h.n != 1); p_h = h.pr; for (j_=0; j_<n_; ++j_, p_H += J_H) { for (i_=0; i_<m_; ++i_, p_H+=I_H, p_h+=I_h) { *p_H = *p_h; ; } } } H.dmode = mxNUMBER; /* end */ } /* % add bias unit */ /* if bias */ if ((double)bias) { /* H = [H ones(p, 1)]; */ mccOnesMN(&RM0_, p, 1); mccCatenateColumns(&H, &H, &RM0_); /* end */ } mccReturnFirstValue(&plhs_[0], &H); mccReturnValue(&plhs_[1], &Inp); return; }
void mexFunction( int nlhs_, Matrix *plhs_[], int nrhs_, Matrix *prhs_[] ) { int ci_, i_, j_; unsigned flags_; Matrix *Mplhs_[32], *Mprhs_[32]; for (ci_=i_=0; i_<nrhs_; ++i_) { if (prhs_[i_]->pi) { ci_ = 1; break; } if (prhs_[i_]->pr) { break; } } if (ci_) { /***************** Compiler Assumptions **************** * * A complex vector/matrix * C complex vector/matrix * CM0_ complex vector/matrix temporary * CM1_ complex vector/matrix temporary * CM2_ complex vector/matrix temporary * H complex vector/matrix * HH complex vector/matrix * R complex vector/matrix * RM0_ real vector/matrix temporary * RM1_ real vector/matrix temporary * XData complex vector/matrix * YData complex vector/matrix * comp_w_r <function being defined> * csize integer scalar * design <function> * diag <function> * dummy integer scalar * error <function> * hhsize integer scalar * indim integer scalar * indim1 integer scalar * inv <function> * invA complex vector/matrix * lambda complex vector/matrix * nargin <function> * nargout <function> * ones <function> * outdim integer scalar * phsize1 integer scalar * phsize2 integer scalar * pinv <function> * pinvH complex vector/matrix * size <function> * w complex vector/matrix * xsize integer scalar * ysize integer scalar *******************************************************/ Matrix w; Matrix H; Matrix invA; Matrix C; Matrix R; Matrix XData; Matrix YData; Matrix lambda; int indim; int xsize; int outdim; int ysize; int indim1; int csize; Matrix HH; int dummy; int hhsize; Matrix A; int phsize1; int phsize2; Matrix pinvH; Matrix CM0_; Matrix RM0_; Matrix RM1_; Matrix CM1_; Matrix CM2_; mccComplexInit(C); mccImport(&C, ((nrhs_>0) ? prhs_[0] : 0), 0, 0); mccComplexInit(R); mccImport(&R, ((nrhs_>1) ? prhs_[1] : 0), 0, 0); mccComplexInit(XData); mccImport(&XData, ((nrhs_>2) ? prhs_[2] : 0), 0, 0); mccComplexInit(YData); mccImportCopy(&YData, ((nrhs_>3) ? prhs_[3] : 0), 0, 0); mccComplexInit(lambda); mccImport(&lambda, ((nrhs_>4) ? prhs_[4] : 0), 0, 0); mccComplexInit(w); mccComplexInit(H); mccComplexInit(invA); mccComplexInit(HH); mccComplexInit(A); mccComplexInit(pinvH); mccComplexInit(CM0_); mccRealInit(RM0_); mccRealInit(RM1_); mccComplexInit(CM1_); mccComplexInit(CM2_); /* % Computes the optimal weight vector for a RBF-network with regularisation */ /* % with the pseudoinverse of H */ /* % [w, H, invA]=comp_w_r(C, R, XData, YData, lambda) */ /* % Input */ /* % C List of centres (Indim-by-m: [c_1 c_2 ... c_m]) (passed to design) */ /* % R Scale factors: scalar, n-vector, or n-by-n matrix (passed to design) */ /* % XData Input training data (Indim-by-p: [x_1 x_2 x_3 ... x_p]) */ /* % YData Output training data (Outdim-by-p: [y_1 y_2 ... y_p]) */ /* % [weights, invA, lambda]=comp_w(H_In, YData, old_lambda) */ /* % Input */ /* % H_in Designmatrix (p-by-m: [h_1(x_1) h2(x_1) ... h_m(x_1) ; ... ; h_p(x_1) ... ]) */ /* % YData Output training data (n-by-p: [y_1 y_2 ... y_p]) */ /* % [weights, lambda]=comp_w(H_In, invA, YData, old_lambda) */ /* % Input */ /* % pinvH Pseudoinverse of Designmatrix (m-by-p) */ /* % YData Output training data (Outdim-by-p) */ /* % Output */ /* % w optimal weight vector (Outdim-by-m) */ /* % H Design matrix (p-by-m) */ /* % pinvH Pseudoinverse of Designmatrix (m-by-p) */ /* if nargin==5, */ if ((mccNargin() == 5)) { /* % check dimensions */ /* [indim, xsize]=size(XData) ; */ mccGetMatrixSize(&indim,&xsize, &XData); /* [outdim, ysize]=size(YData) ; */ mccGetMatrixSize(&outdim,&ysize, &YData); /* [indim1, csize]=size(C) ; */ mccGetMatrixSize(&indim1,&csize, &C); /* if xsize~=ysize, */ if ((xsize != ysize)) { /* error('X and Y must have same number of columns') ; */ mccError(&S0_); /* end ; */ } /* if indim1~=indim */ if ((indim1 != indim)) { /* error('C and X must have same number of columns') ; */ mccError(&S1_); /* end ; */ } /* % design */ /* H=design(XData, C, R) ; */ Mprhs_[0] = &XData; Mprhs_[1] = &C; Mprhs_[2] = &R; Mplhs_[0] = &H; mccCallMATLAB(1, Mplhs_, 3, Mprhs_, "design", 43); /* HH=H'*H ; */ mccConjTrans(&CM0_, &H); mccMultiply(&HH, &CM0_, &H); /* [dummy,hhsize]=size(HH) ; */ mccGetMatrixSize(&dummy,&hhsize, &HH); /* % compute inverse of variance matrix A */ /* %%% */ /* A=HH + lambda*diag(ones(1,hhsize)) ; */ mccOnesMN(&RM0_, 1, hhsize); Mprhs_[0] = &RM0_; Mplhs_[0] = &RM1_; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "diag", 50); mccMultiply(&CM0_, &lambda, &RM1_); { int m_=1, n_=1, cx_ = 0; double t_; double *p_A; int I_A=1; double *q_A; double *p_HH; int I_HH=1; double *q_HH; double *p_CM0_; int I_CM0_=1; double *q_CM0_; m_ = mcmCalcResultSize(m_, &n_, HH.m, HH.n); m_ = mcmCalcResultSize(m_, &n_, CM0_.m, CM0_.n); mccAllocateMatrix(&A, m_, n_); I_A = (A.m != 1 || A.n != 1); p_A = A.pr; q_A = A.pi; I_HH = (HH.m != 1 || HH.n != 1); p_HH = HH.pr; q_HH = HH.pi; I_CM0_ = (CM0_.m != 1 || CM0_.n != 1); p_CM0_ = CM0_.pr; q_CM0_ = CM0_.pi; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_A+=I_A, q_A+=I_A, p_HH+=I_HH, q_HH+=I_HH, p_CM0_+=I_CM0_, q_CM0_+=I_CM0_) { *p_A = (*p_HH + *p_CM0_); *q_A = (*q_HH + *q_CM0_); ; } } } A.dmode = mxNUMBER; /* invA=inv(A) ; */ Mprhs_[0] = &A; Mplhs_[0] = &invA; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "inv", 51); /* %i2A=iA^2 ; */ /* % compute projection matrix */ /* %%% */ /* %P=H*iA*H' ; */ /* %P=eye(size(P)) - P ; */ /* %P2=P^2 ; */ /* w=invA*H'*YData' ; */ mccConjTrans(&CM0_, &H); mccMultiply(&CM1_, &invA, &CM0_); mccConjTrans(&CM2_, &YData); mccMultiply(&w, &CM1_, &CM2_); /* % compute new lambda */ /* %lambda_old=YData*P2*YData'*trace(iA-lambda_old*i2A)/(w'*iA*w*trace(P)) */ /* elseif nargin==2 */ } else { if ((mccNargin() == 2)) { /* % */ /* error('not impl.') ; */ mccError(&S2_); /* [ysize, outdim]=size(YData) ; */ mccGetMatrixSize(&ysize,&outdim, &YData); /* [phsize1, phsize2]=size(C) ; */ mccGetMatrixSize(&phsize1,&phsize2, &C); /* YData=R ; */ mccCopy(&YData, &R); /* if nargout==2 */ if ((mccNargout() == 2)) { /* % C is the design-matrix */ /* if phsize1~=ysize, */ if ((phsize1 != ysize)) { /* error('Y <-> H mismatch') ; */ mccError(&S3_); /* end ; */ } /* pinvH=pinv(C) ; */ Mprhs_[0] = &C; Mplhs_[0] = &pinvH; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "pinv", 77); /* else */ } else { /* % C is the pseudoinverse of the design-matrix */ /* if phsize2~=ysize, */ if ((phsize2 != ysize)) { /* error('Y <-> pinvH mismatch') ; */ mccError(&S4_); /* end ; */ } /* pinvH=C ; */ mccCopy(&pinvH, &C); /* end ; */ } /* else */ } else { /* error('parameter mismatch') ; */ mccError(&S5_); /* end ; */ } } mccReturnFirstValue(&plhs_[0], &w); mccReturnValue(&plhs_[1], &H); mccReturnValue(&plhs_[2], &invA); } else { /***************** Compiler Assumptions **************** * * A complex vector/matrix * C real vector/matrix * CM0_ complex vector/matrix temporary * CM1_ complex vector/matrix temporary * H complex vector/matrix * HH complex vector/matrix * R real vector/matrix * RM0_ real vector/matrix temporary * RM1_ real vector/matrix temporary * RM2_ real vector/matrix temporary * XData real vector/matrix * YData real vector/matrix * comp_w_r <function being defined> * csize integer scalar * design <function> * diag <function> * dummy integer scalar * error <function> * hhsize integer scalar * indim integer scalar * indim1 integer scalar * inv <function> * invA complex vector/matrix * lambda real vector/matrix * nargin <function> * nargout <function> * ones <function> * outdim integer scalar * phsize1 integer scalar * phsize2 integer scalar * pinv <function> * pinvH real vector/matrix * size <function> * w complex vector/matrix * xsize integer scalar * ysize integer scalar *******************************************************/ Matrix w; Matrix H; Matrix invA; Matrix C; Matrix R; Matrix XData; Matrix YData; Matrix lambda; int indim; int xsize; int outdim; int ysize; int indim1; int csize; Matrix HH; int dummy; int hhsize; Matrix A; int phsize1; int phsize2; Matrix pinvH; Matrix CM0_; Matrix RM0_; Matrix RM1_; Matrix RM2_; Matrix CM1_; mccRealInit(C); mccImport(&C, ((nrhs_>0) ? prhs_[0] : 0), 0, 0); mccRealInit(R); mccImport(&R, ((nrhs_>1) ? prhs_[1] : 0), 0, 0); mccRealInit(XData); mccImport(&XData, ((nrhs_>2) ? prhs_[2] : 0), 0, 0); mccRealInit(YData); mccImportCopy(&YData, ((nrhs_>3) ? prhs_[3] : 0), 0, 0); mccRealInit(lambda); mccImport(&lambda, ((nrhs_>4) ? prhs_[4] : 0), 0, 0); mccComplexInit(w); mccComplexInit(H); mccComplexInit(invA); mccComplexInit(HH); mccComplexInit(A); mccRealInit(pinvH); mccComplexInit(CM0_); mccRealInit(RM0_); mccRealInit(RM1_); mccRealInit(RM2_); mccComplexInit(CM1_); /* % Computes the optimal weight vector for a RBF-network with regularisation */ /* % with the pseudoinverse of H */ /* % [w, H, invA]=comp_w_r(C, R, XData, YData, lambda) */ /* % Input */ /* % C List of centres (Indim-by-m: [c_1 c_2 ... c_m]) (passed to design) */ /* % R Scale factors: scalar, n-vector, or n-by-n matrix (passed to design) */ /* % XData Input training data (Indim-by-p: [x_1 x_2 x_3 ... x_p]) */ /* % YData Output training data (Outdim-by-p: [y_1 y_2 ... y_p]) */ /* % [weights, invA, lambda]=comp_w(H_In, YData, old_lambda) */ /* % Input */ /* % H_in Designmatrix (p-by-m: [h_1(x_1) h2(x_1) ... h_m(x_1) ; ... ; h_p(x_1) ... ]) */ /* % YData Output training data (n-by-p: [y_1 y_2 ... y_p]) */ /* % [weights, lambda]=comp_w(H_In, invA, YData, old_lambda) */ /* % Input */ /* % pinvH Pseudoinverse of Designmatrix (m-by-p) */ /* % YData Output training data (Outdim-by-p) */ /* % Output */ /* % w optimal weight vector (Outdim-by-m) */ /* % H Design matrix (p-by-m) */ /* % pinvH Pseudoinverse of Designmatrix (m-by-p) */ /* if nargin==5, */ if ((mccNargin() == 5)) { /* % check dimensions */ /* [indim, xsize]=size(XData) ; */ mccGetMatrixSize(&indim,&xsize, &XData); /* [outdim, ysize]=size(YData) ; */ mccGetMatrixSize(&outdim,&ysize, &YData); /* [indim1, csize]=size(C) ; */ mccGetMatrixSize(&indim1,&csize, &C); /* if xsize~=ysize, */ if ((xsize != ysize)) { /* error('X and Y must have same number of columns') ; */ mccError(&S6_); /* end ; */ } /* if indim1~=indim */ if ((indim1 != indim)) { /* error('C and X must have same number of columns') ; */ mccError(&S7_); /* end ; */ } /* % design */ /* H=design(XData, C, R) ; */ Mprhs_[0] = &XData; Mprhs_[1] = &C; Mprhs_[2] = &R; Mplhs_[0] = &H; mccCallMATLAB(1, Mplhs_, 3, Mprhs_, "design", 43); /* HH=H'*H ; */ mccConjTrans(&CM0_, &H); mccMultiply(&HH, &CM0_, &H); /* [dummy,hhsize]=size(HH) ; */ mccGetMatrixSize(&dummy,&hhsize, &HH); /* % compute inverse of variance matrix A */ /* %%% */ /* A=HH + lambda*diag(ones(1,hhsize)) ; */ mccOnesMN(&RM0_, 1, hhsize); Mprhs_[0] = &RM0_; Mplhs_[0] = &RM1_; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "diag", 50); mccRealMatrixMultiply(&RM2_, &lambda, &RM1_); { int m_=1, n_=1, cx_ = 0; double t_; double *p_A; int I_A=1; double *q_A; double *p_HH; int I_HH=1; double *q_HH; double *p_RM2_; int I_RM2_=1; m_ = mcmCalcResultSize(m_, &n_, HH.m, HH.n); m_ = mcmCalcResultSize(m_, &n_, RM2_.m, RM2_.n); mccAllocateMatrix(&A, m_, n_); I_A = (A.m != 1 || A.n != 1); p_A = A.pr; q_A = A.pi; I_HH = (HH.m != 1 || HH.n != 1); p_HH = HH.pr; q_HH = HH.pi; I_RM2_ = (RM2_.m != 1 || RM2_.n != 1); p_RM2_ = RM2_.pr; for (j_=0; j_<n_; ++j_) { for (i_=0; i_<m_; ++i_, p_A+=I_A, q_A+=I_A, p_HH+=I_HH, q_HH+=I_HH, p_RM2_+=I_RM2_) { *p_A = (*p_HH + *p_RM2_); *q_A = (*q_HH + 0.); ; } } } A.dmode = mxNUMBER; /* invA=inv(A) ; */ Mprhs_[0] = &A; Mplhs_[0] = &invA; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "inv", 51); /* %i2A=iA^2 ; */ /* % compute projection matrix */ /* %%% */ /* %P=H*iA*H' ; */ /* %P=eye(size(P)) - P ; */ /* %P2=P^2 ; */ /* w=invA*H'*YData' ; */ mccConjTrans(&CM0_, &H); mccMultiply(&CM1_, &invA, &CM0_); mccConjTrans(&RM2_, &YData); mccMultiply(&w, &CM1_, &RM2_); /* % compute new lambda */ /* %lambda_old=YData*P2*YData'*trace(iA-lambda_old*i2A)/(w'*iA*w*trace(P)) */ /* elseif nargin==2 */ } else { if ((mccNargin() == 2)) { /* % */ /* error('not impl.') ; */ mccError(&S8_); /* [ysize, outdim]=size(YData) ; */ mccGetMatrixSize(&ysize,&outdim, &YData); /* [phsize1, phsize2]=size(C) ; */ mccGetMatrixSize(&phsize1,&phsize2, &C); /* YData=R ; */ mccCopy(&YData, &R); /* if nargout==2 */ if ((mccNargout() == 2)) { /* % C is the design-matrix */ /* if phsize1~=ysize, */ if ((phsize1 != ysize)) { /* error('Y <-> H mismatch') ; */ mccError(&S9_); /* end ; */ } /* pinvH=pinv(C) ; */ Mprhs_[0] = &C; Mplhs_[0] = &pinvH; mccCallMATLAB(1, Mplhs_, 1, Mprhs_, "pinv", 77); /* else */ } else { /* % C is the pseudoinverse of the design-matrix */ /* if phsize2~=ysize, */ if ((phsize2 != ysize)) { /* error('Y <-> pinvH mismatch') ; */ mccError(&S10_); /* end ; */ } /* pinvH=C ; */ mccCopy(&pinvH, &C); /* end ; */ } /* else */ } else { /* error('parameter mismatch') ; */ mccError(&S11_); /* end ; */ } } mccReturnFirstValue(&plhs_[0], &w); mccReturnValue(&plhs_[1], &H); mccReturnValue(&plhs_[2], &invA); } return; }