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;
}
