linearOffsetMatcher::linearOffsetMatcher( int nFaces_,int nPer,const int *facesA,const int *facesB,int idxBase, int nNodes_,const CkVector3d *nodeLocs): a(nFaces_,nPer,facesA,idxBase,nodeLocs), b(nFaces_,nPer,facesB,idxBase,nodeLocs), nNodes(nNodes_),nFaces(nFaces_) { //Compute the offset from A to B by taking the difference of their centroids: CkVector3d a_sum(0.0), b_sum(0.0); for (int f=0;f<nFaces;f++) { a_sum+=a.getFaceLoc(f); b_sum+=b.getFaceLoc(f); } a2b_del=(b_sum-a_sum)*(1.0/nFaces); //Derive the matching tolerance from the edge length (for either face set) minTol=a.getMinEdgeLength()*0.001; }
/* * fft_bandpower_calculate * data: the signal of 1 dimension vector * Fs: the frequency provide * band: the band provided, should have upper and lower bound * Arguments : const double data[256] * double Fs * double band[2] * double *totalpower * double *pband * Return Type : void */ void fft_bandpower_calculate(const double data[256], double Fs, double band[2], double *totalpower, double *pband) { creal_T A[256]; double y; double f[129]; int i; creal_T b_A[256]; creal_T c_A[129]; double c_power[129]; boolean_T bv0[129]; boolean_T bv1[129]; double dv0[129]; unsigned char tmp_data[129]; int trueCount; int partialTrueCount; double power_data[129]; int power_size[2]; int tmp_size[2]; double b_tmp_data[129]; /* get of the data */ fft(data, A); y = Fs / 2.0; linspace(f); for (i = 0; i < 129; i++) { f[i] *= y; } for (i = 0; i < 256; i++) { if (A[i].im == 0.0) { b_A[i].re = A[i].re / 256.0; b_A[i].im = 0.0; } else if (A[i].re == 0.0) { b_A[i].re = 0.0; b_A[i].im = A[i].im / 256.0; } else { b_A[i].re = A[i].re / 256.0; b_A[i].im = A[i].im / 256.0; } } memcpy(&c_A[0], &b_A[0], 129U * sizeof(creal_T)); b_abs(c_A, c_power); for (i = 0; i < 129; i++) { c_power[i] *= 2.0; } /* see if band power is in side the frequency range */ if (band[1] > f[128]) { band[1] = f[128]; } if (band[0] < f[0]) { /* if the band lower bound is less than f(1) */ band[0] = f[0]; } for (i = 0; i < 129; i++) { bv0[i] = (f[i] >= band[0]); bv1[i] = (f[i] <= band[1]); } power(c_power, dv0); *totalpower = sum(dv0); trueCount = 0; for (i = 0; i < 129; i++) { if (bv0[i] && bv1[i]) { trueCount++; } } partialTrueCount = 0; for (i = 0; i < 129; i++) { if (bv0[i] && bv1[i]) { tmp_data[partialTrueCount] = (unsigned char)(i + 1); partialTrueCount++; } } power_size[0] = 1; power_size[1] = trueCount; for (i = 0; i < trueCount; i++) { power_data[i] = c_power[tmp_data[i] - 1]; } b_power(power_data, power_size, b_tmp_data, tmp_size); *pband = b_sum(b_tmp_data, tmp_size); }
bool CartoonEngine::Convert2Painting(int neighbor, int levels) { if ((image_.empty()) || (CV_8UC3 != image_.type())) return false; // Resize image for fast processing. cv::Size2i small_size(cols_, rows_); cv::Mat img = image_; if ((rows_ > 300) || (cols_ > 300)) { if (rows_ > cols_) { small_size.height = 300; small_size.width = static_cast<int>(300 * (static_cast<float>(cols_) / rows_)); } else { small_size.width = 300; small_size.height = static_cast<int>(300 * (static_cast<float>(rows_) / cols_)); } cv::resize(img, img, small_size); } painting_.create(small_size.height, small_size.width, CV_8UC3); vector<int> hist(levels, 0); vector<int> b_sum(levels, 0); vector<int> g_sum(levels, 0); vector<int> r_sum(levels, 0); for (int r = 0; r < small_size.height; ++r) { for (int c = 0; c < small_size.width; ++c) { for (int i = 0; i < levels; ++i) { hist[i] = 0; b_sum[i] = g_sum[i] = r_sum[i] = 0; } int r_start = std::max(0, r - neighbor); int r_end = std::min(small_size.height, r + neighbor); int c_start = std::max(0, c - neighbor); int c_end = std::min(small_size.width, c + neighbor); for (int rr = r_start; rr < r_end; ++rr) { for (int cc = c_start; cc < c_end; ++cc) { cv::Vec3b pixel = img.at<cv::Vec3b>(rr, cc); int ind = static_cast<int>((pixel[0] + pixel[1] + pixel[2]) / 3) * (levels - 1) / 255; ++hist[ind]; b_sum[ind] += static_cast<int>(pixel[0]); g_sum[ind] += static_cast<int>(pixel[1]); r_sum[ind] += static_cast<int>(pixel[2]); } } int new_ind = 0; int cur_max = hist[0]; for (int l = 1; l < levels; ++l) { if (hist[l] > hist[new_ind]) { new_ind = l; cur_max = hist[l]; } } painting_.at<cv::Vec3b>(r, c)[0] = static_cast<uchar>(b_sum[new_ind] / cur_max); painting_.at<cv::Vec3b>(r, c)[1] = static_cast<uchar>(g_sum[new_ind] / cur_max); painting_.at<cv::Vec3b>(r, c)[2] = static_cast<uchar>(r_sum[new_ind] / cur_max); } } if (small_size.width != cols_) { cv::resize(painting_, painting_, cv::Size2i(cols_, rows_)); } return true; }
/* * function [lp]=gaussmixp(y,m,v,w) * y = cat(1, testSamples(1).mfcc{:}); * m = gmm.M; * v = gmm.V; * w = gmm.W; */ void gaussmixp(const real_T y[2004], const real_T m[108], const real_T v[108], const real_T w[9], real_T lp[167]) { real_T b[108]; real_T dv0[108]; real_T b_b[9]; real_T lvm[9]; int32_T ix; real_T mx[167]; real_T kk[1503]; real_T km[1503]; static real_T b_y[18036]; int32_T iy; real_T dv1[18036]; real_T x[1503]; int32_T i; int32_T ixstart; int32_T ixstop; real_T mtmp; int32_T b_ix; boolean_T exitg1; real_T ps[167]; /* GAUSSMIXP calculate probability densities from a Gaussian mixture model */ /* */ /* Inputs: n data values, k mixtures, p parameters, q data vector size */ /* */ /* Y(n,q) = input data */ /* M(k,p) = mixture means for x(p) */ /* V(k,p) or V(p,p,k) variances (diagonal or full) */ /* W(k,1) = weights */ /* A(q,p), B(q) = transformation: y=x*a'+b' (where y and x are row vectors) */ /* if A is omitted, it is assumed to be the first q rows of the */ /* identity matrix. B defaults to zero. */ /* Note that most commonly, q=p and A and B are omitted entirely. */ /* */ /* Outputs */ /* */ /* LP(n,1) = log probability of each data point */ /* RP(n,k) = relative probability of each mixture */ /* KH(n,1) = highest probability mixture */ /* KP(n,1) = relative probability of highest probability mixture */ /* Copyright (C) Mike Brookes 2000-2009 */ /* Version: $Id: gaussmixp.m,v 1.3 2009/04/08 07:51:21 dmb Exp $ */ /* */ /* VOICEBOX is a MATLAB toolbox for speech processing. */ /* Home page: http://www.ee.ic.ac.uk/hp/staff/dmb/voicebox/voicebox.html */ /* */ /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */ /* This program is free software; you can redistribute it and/or modify */ /* it under the terms of the GNU General Public License as published by */ /* the Free Software Foundation; either version 2 of the License, or */ /* (at your option) any later version. */ /* */ /* This program is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ /* GNU General Public License for more details. */ /* */ /* You can obtain a copy of the GNU General Public License from */ /* http://www.gnu.org/copyleft/gpl.html or by writing to */ /* Free Software Foundation, Inc.,675 Mass Ave, Cambridge, MA 02139, USA. */ /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */ /* 'gaussmixp:49' [n,q]=size(y); */ /* 'gaussmixp:50' [k,p]=size(m); */ /* 'gaussmixp:51' memsize=voicebox('memsize'); */ voicebox(); /* set memory size to use */ /* 'gaussmixp:53' lp=zeros(n,1); */ memset((void *)&lp[0], 0, 167U * sizeof(real_T)); /* 'gaussmixp:54' wk=ones(k,1); */ /* 'gaussmixp:56' vi=-0.5*v.^(-1); */ power(v, b); /* data-independent scale factor in exponent */ /* 'gaussmixp:57' lvm=log(w)-0.5*sum(log(v),2); */ memcpy((void *)&dv0[0], (void *)&v[0], 108U * sizeof(real_T)); c_log(dv0); sum(dv0, b_b); memcpy((void *)&lvm[0], (void *)&w[0], 9U * sizeof(real_T)); b_log(lvm); for (ix = 0; ix < 9; ix++) { lvm[ix] -= 0.5 * b_b[ix]; } /* log of external scale factor (excluding -0.5*q*log(2pi) term) */ /* 'gaussmixp:58' ii=1:n; */ /* 'gaussmixp:59' wnj=ones(1,n); */ /* 'gaussmixp:60' kk=repmat(ii,k,1); */ for (ix = 0; ix < 167; ix++) { mx[ix] = 1.0 + (real_T)ix; } repmat(mx, kk); /* 'gaussmixp:61' km=repmat(1:k,1,n); */ for (ix = 0; ix < 9; ix++) { b_b[ix] = 1.0 + (real_T)ix; } b_repmat(b_b, km); /* 'gaussmixp:62' py=reshape(sum((y(kk(:),:)-m(km(:),:)).^2.*vi(km(:),:),2),k,n)+lvm(:,wnj); */ for (ix = 0; ix < 12; ix++) { for (iy = 0; iy < 1503; iy++) { b_y[iy + 1503 * ix] = y[((int32_T)kk[iy] + 167 * ix) - 1] - m[((int32_T) km[iy] + 9 * ix) - 1]; } } b_power(b_y, dv1); for (ix = 0; ix < 12; ix++) { for (iy = 0; iy < 1503; iy++) { b_y[iy + 1503 * ix] = dv1[iy + 1503 * ix] * (-0.5 * b[((int32_T)km[iy] + 9 * ix) - 1]); } } b_sum(b_y, x); memcpy((void *)&kk[0], (void *)&x[0], 1503U * sizeof(real_T)); for (ix = 0; ix < 167; ix++) { for (iy = 0; iy < 9; iy++) { km[iy + 9 * ix] = kk[iy + 9 * ix] + lvm[iy]; } } /* 'gaussmixp:63' mx=max(py,[],1); */ ix = -8; iy = -1; for (i = 0; i < 167; i++) { ix += 9; ixstart = ix; ixstop = ix + 8; mtmp = km[ix - 1]; if (rtIsNaN(km[ix - 1])) { b_ix = ix; exitg1 = 0U; while ((exitg1 == 0U) && (b_ix + 1 <= ixstop)) { ixstart = b_ix + 1; if (!rtIsNaN(km[b_ix])) { mtmp = km[b_ix]; exitg1 = 1U; } else { b_ix++; } } } if (ixstart < ixstop) { while (ixstart + 1 <= ixstop) { if (km[ixstart] > mtmp) { mtmp = km[ixstart]; } ixstart++; } } iy++; mx[iy] = mtmp; } /* find normalizing factor for each data point to prevent underflow when using exp() */ /* 'gaussmixp:64' px=exp(py-mx(wk,:)); */ for (ix = 0; ix < 167; ix++) { for (iy = 0; iy < 9; iy++) { kk[iy + 9 * ix] = km[iy + 9 * ix] - mx[ix]; } } b_exp(kk); /* find normalized probability of each mixture for each datapoint */ /* 'gaussmixp:65' ps=sum(px,1); */ c_sum(kk, ps); /* total normalized likelihood of each data point */ /* 'gaussmixp:66' lp(ii)=log(ps)+mx; */ d_log(ps); for (ix = 0; ix < 167; ix++) { /* 'gaussmixp:67' lp=lp-0.5*q*log(2*pi); */ lp[ix] = (ps[ix] + mx[ix]) - 11.027262398456072; } }
void sammon(sammonStackData *SD, const real_T x[1000000], real_T y[2000], real_T *E) { real_T B; int32_T i; real_T dv0[1000]; int32_T b_i; boolean_T exitg1; real_T alpha1; real_T beta1; char_T TRANSB; char_T TRANSA; ptrdiff_t m_t; ptrdiff_t n_t; ptrdiff_t k_t; ptrdiff_t lda_t; ptrdiff_t ldb_t; ptrdiff_t ldc_t; double * alpha1_t; double * Aia0_t; double * Bib0_t; double * beta1_t; double * Cic0_t; real_T g[2000]; real_T y2[2000]; real_T b_y[2000]; real_T c_y[2000]; real_T d_y[2000]; real_T e_y[2000]; real_T b_g[2000]; int32_T j; int32_T b_j; boolean_T exitg2; real_T dv1[1000]; real_T E_new; /* #codgen */ /* */ /* SAMMON - apply Sammon's nonlinear mapping */ /* */ /* Y = SAMMON(X) applies Sammon's nonlinear mapping procedure on */ /* multivariate data X, where each row represents a pattern and each column */ /* represents a feature. On completion, Y contains the corresponding */ /* co-ordinates of each point on the map. By default, a two-dimensional */ /* map is created. Note if X contains any duplicated rows, SAMMON will */ /* fail (ungracefully). */ /* */ /* [Y,E] = SAMMON(X) also returns the value of the cost function in E (i.e. */ /* the stress of the mapping). */ /* */ /* An N-dimensional output map is generated by Y = SAMMON(X,N) . */ /* */ /* A set of optimisation options can also be specified using a third */ /* argument, Y = SAMMON(X,N,OPTS) , where OPTS is a structure with fields: */ /* */ /* MaxIter - maximum number of iterations */ /* TolFun - relative tolerance on objective function */ /* MaxHalves - maximum number of step halvings */ /* Input - {'raw','distance'} if set to 'distance', X is */ /* interpreted as a matrix of pairwise distances. */ /* Display - {'off', 'on', 'iter'} */ /* Initialisation - {'pca', 'random'} */ /* */ /* The default options structure can be retrieved by calling SAMMON with */ /* no parameters. */ /* */ /* References : */ /* */ /* [1] Sammon, John W. Jr., "A Nonlinear Mapping for Data Structure */ /* Analysis", IEEE Transactions on Computers, vol. C-18, no. 5, */ /* pp 401-409, May 1969. */ /* */ /* See also : SAMMON_TEST */ /* */ /* File : sammon.m */ /* */ /* Date : Monday 12th November 2007. */ /* */ /* Author : Gavin C. Cawley and Nicola L. C. Talbot */ /* */ /* Description : Simple vectorised MATLAB implementation of Sammon's non-linear */ /* mapping algorithm [1]. */ /* */ /* References : [1] Sammon, John W. Jr., "A Nonlinear Mapping for Data */ /* Structure Analysis", IEEE Transactions on Computers, */ /* vol. C-18, no. 5, pp 401-409, May 1969. */ /* */ /* History : 10/08/2004 - v1.00 */ /* 11/08/2004 - v1.10 Hessian made positive semidefinite */ /* 13/08/2004 - v1.11 minor optimisation */ /* 12/11/2007 - v1.20 initialisation using the first n principal */ /* components. */ /* */ /* Thanks : Dr Nick Hamilton ([email protected]) for supplying the */ /* code for implementing initialisation using the first n */ /* principal components (introduced in v1.20). */ /* */ /* To do : The current version does not take advantage of the symmetry */ /* of the distance matrix in order to allow for easy */ /* vectorisation. This may not be a good choice for very large */ /* datasets, so perhaps one day I'll get around to doing a MEX */ /* version using the BLAS library etc. for very large datasets. */ /* */ /* Copyright : (c) Dr Gavin C. Cawley, November 2007. */ /* */ /* This program is free software; you can redistribute it and/or modify */ /* it under the terms of the GNU General Public License as published by */ /* the Free Software Foundation; either version 2 of the License, or */ /* (at your option) any later version. */ /* */ /* This program is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ /* GNU General Public License for more details. */ /* */ /* You should have received a copy of the GNU General Public License */ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /* use the default options structure */ /* create distance matrix unless given by parameters */ emlrtPushRtStackR2012b(&emlrtRSI, emlrtRootTLSGlobal); euclid(SD, x, x, SD->f2.D); emlrtPopRtStackR2012b(&emlrtRSI, emlrtRootTLSGlobal); /* remaining initialisation */ B = b_sum(SD->f2.D); eye(SD->f2.delta); for (i = 0; i < 1000000; i++) { SD->f2.D[i] += SD->f2.delta[i]; } rdivide(1.0, SD->f2.D, SD->f2.Dinv); emlrtPushRtStackR2012b(&b_emlrtRSI, emlrtRootTLSGlobal); randn(y); emlrtPopRtStackR2012b(&b_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&c_emlrtRSI, emlrtRootTLSGlobal); b_euclid(SD, y, y, SD->f2.d); eye(SD->f2.delta); for (i = 0; i < 1000000; i++) { SD->f2.d[i] += SD->f2.delta[i]; } emlrtPopRtStackR2012b(&c_emlrtRSI, emlrtRootTLSGlobal); rdivide(1.0, SD->f2.d, SD->f2.dinv); for (i = 0; i < 1000000; i++) { SD->f2.b_D[i] = SD->f2.D[i] - SD->f2.d[i]; } power(SD->f2.b_D, SD->f2.delta); for (i = 0; i < 1000000; i++) { SD->f2.d[i] = SD->f2.delta[i] * SD->f2.Dinv[i]; } d_sum(SD->f2.d, dv0); *E = e_sum(dv0); /* get on with it */ b_i = 0; exitg1 = FALSE; while ((exitg1 == FALSE) && (b_i < 500)) { /* compute gradient, Hessian and search direction (note it is actually */ /* 1/4 of the gradient and Hessian, but the step size is just the ratio */ /* of the gradient and the diagonal of the Hessian so it doesn't matter). */ for (i = 0; i < 1000000; i++) { SD->f2.delta[i] = SD->f2.dinv[i] - SD->f2.Dinv[i]; } emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); alpha1 = 1.0; beta1 = 0.0; TRANSB = 'N'; TRANSA = 'N'; for (i = 0; i < 2000; i++) { SD->f2.y_old[i] = 1.0; SD->f2.deltaone[i] = 0.0; } emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); m_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); n_t = (ptrdiff_t)(2); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); k_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); lda_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldb_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldc_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); alpha1_t = (double *)(&alpha1); emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); Aia0_t = (double *)(&SD->f2.delta[0]); emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); Bib0_t = (double *)(&SD->f2.y_old[0]); emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); beta1_t = (double *)(&beta1); emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); Cic0_t = (double *)(&SD->f2.deltaone[0]); emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t); emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&e_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); alpha1 = 1.0; beta1 = 0.0; TRANSB = 'N'; TRANSA = 'N'; memset(&g[0], 0, 2000U * sizeof(real_T)); emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); m_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); n_t = (ptrdiff_t)(2); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); k_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); lda_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldb_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldc_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); alpha1_t = (double *)(&alpha1); emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); Aia0_t = (double *)(&SD->f2.delta[0]); emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); Bib0_t = (double *)(&y[0]); emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); beta1_t = (double *)(&beta1); emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); Cic0_t = (double *)(&g[0]); emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t); emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); for (i = 0; i < 2000; i++) { g[i] -= y[i] * SD->f2.deltaone[i]; } emlrtPopRtStackR2012b(&e_emlrtRSI, emlrtRootTLSGlobal); c_power(SD->f2.dinv, SD->f2.delta); b_power(y, y2); emlrtPushRtStackR2012b(&f_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); alpha1 = 1.0; beta1 = 0.0; TRANSB = 'N'; TRANSA = 'N'; memset(&b_y[0], 0, 2000U * sizeof(real_T)); emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); m_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); n_t = (ptrdiff_t)(2); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); k_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); lda_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldb_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldc_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); alpha1_t = (double *)(&alpha1); emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); Aia0_t = (double *)(&SD->f2.delta[0]); emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); Bib0_t = (double *)(&y2[0]); emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); beta1_t = (double *)(&beta1); emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); Cic0_t = (double *)(&b_y[0]); emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t); emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); for (i = 0; i < 2000; i++) { c_y[i] = 2.0 * y[i]; } emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); alpha1 = 1.0; beta1 = 0.0; TRANSB = 'N'; TRANSA = 'N'; memset(&d_y[0], 0, 2000U * sizeof(real_T)); emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); m_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); n_t = (ptrdiff_t)(2); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); k_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); lda_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldb_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldc_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); alpha1_t = (double *)(&alpha1); emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); Aia0_t = (double *)(&SD->f2.delta[0]); emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); Bib0_t = (double *)(&y[0]); emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); beta1_t = (double *)(&beta1); emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); Cic0_t = (double *)(&d_y[0]); emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t); emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); alpha1 = 1.0; beta1 = 0.0; TRANSB = 'N'; TRANSA = 'N'; for (i = 0; i < 2000; i++) { SD->f2.y_old[i] = 1.0; e_y[i] = 0.0; } emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); m_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); n_t = (ptrdiff_t)(2); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); k_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); lda_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldb_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); ldc_t = (ptrdiff_t)(1000); emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); alpha1_t = (double *)(&alpha1); emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); Aia0_t = (double *)(&SD->f2.delta[0]); emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); Bib0_t = (double *)(&SD->f2.y_old[0]); emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); beta1_t = (double *)(&beta1); emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); Cic0_t = (double *)(&e_y[0]); emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal); emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t); emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal); emlrtPopRtStackR2012b(&f_emlrtRSI, emlrtRootTLSGlobal); for (i = 0; i < 2000; i++) { SD->f2.y_old[i] = ((b_y[i] - SD->f2.deltaone[i]) - c_y[i] * d_y[i]) + y2[i] * e_y[i]; b_g[i] = -g[i]; } b_abs(SD->f2.y_old, y2); for (i = 0; i < 2000; i++) { SD->f2.deltaone[i] = y2[i]; SD->f2.y_old[i] = y[i]; } b_rdivide(b_g, SD->f2.deltaone, y2); /* use step-halving procedure to ensure progress is made */ j = 1; b_j = 0; exitg2 = FALSE; while ((exitg2 == FALSE) && (b_j < 20)) { j = b_j + 1; for (i = 0; i < 2000; i++) { y[i] = SD->f2.y_old[i] + y2[i]; } emlrtPushRtStackR2012b(&g_emlrtRSI, emlrtRootTLSGlobal); b_euclid(SD, y, y, SD->f2.d); eye(SD->f2.delta); for (i = 0; i < 1000000; i++) { SD->f2.d[i] += SD->f2.delta[i]; } emlrtPopRtStackR2012b(&g_emlrtRSI, emlrtRootTLSGlobal); rdivide(1.0, SD->f2.d, SD->f2.dinv); for (i = 0; i < 1000000; i++) { SD->f2.b_D[i] = SD->f2.D[i] - SD->f2.d[i]; } power(SD->f2.b_D, SD->f2.delta); for (i = 0; i < 1000000; i++) { SD->f2.d[i] = SD->f2.delta[i] * SD->f2.Dinv[i]; } d_sum(SD->f2.d, dv1); E_new = e_sum(dv1); if (E_new < *E) { exitg2 = TRUE; } else { for (i = 0; i < 2000; i++) { y2[i] *= 0.5; } b_j++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal); } } /* bomb out if too many halving steps are required */ if ((j == 20) || (muDoubleScalarAbs((*E - E_new) / *E) < 1.0E-9)) { exitg1 = TRUE; } else { /* evaluate termination criterion */ /* report progress */ *E = E_new; b_i++; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal); } } /* fiddle stress to match the original Sammon paper */ *E *= 0.5 / B; }
/* Function Definitions */ static void b_euclid(const emxArray_real_T *x, const emxArray_real_T *y, emxArray_real_T *d) { emxArray_real_T *a; emxArray_real_T *b; emxArray_real_T *r2; emxArray_real_T *r3; int32_T i7; int32_T unnamed_idx_1; int32_T br; emxArray_real_T *b_b; int32_T ar; emxArray_real_T *b_y; uint32_T unnamed_idx_0; uint32_T b_unnamed_idx_1; int32_T cr; int32_T ic; int32_T ib; int32_T ia; emxArray_real_T *b_a; emxArray_real_T *r4; b_emxInit_real_T(&a, 1); emxInit_real_T(&b, 2); emxInit_real_T(&r2, 2); b_emxInit_real_T(&r3, 1); /* all done */ b_power(x, r2); b_sum(r2, a); b_power(y, r2); b_sum(r2, r3); i7 = b->size[0] * b->size[1]; b->size[0] = 1; emxEnsureCapacity((emxArray__common *)b, i7, (int32_T)sizeof(real_T)); unnamed_idx_1 = r3->size[0]; i7 = b->size[0] * b->size[1]; b->size[1] = unnamed_idx_1; emxEnsureCapacity((emxArray__common *)b, i7, (int32_T)sizeof(real_T)); br = r3->size[0]; emxFree_real_T(&r2); for (i7 = 0; i7 < br; i7++) { b->data[i7] = r3->data[i7]; } emxFree_real_T(&r3); emxInit_real_T(&b_b, 2); i7 = b_b->size[0] * b_b->size[1]; b_b->size[0] = 2; b_b->size[1] = y->size[0]; emxEnsureCapacity((emxArray__common *)b_b, i7, (int32_T)sizeof(real_T)); br = y->size[0]; for (i7 = 0; i7 < br; i7++) { for (ar = 0; ar < 2; ar++) { b_b->data[ar + b_b->size[0] * i7] = y->data[i7 + y->size[0] * ar]; } } emxInit_real_T(&b_y, 2); unnamed_idx_0 = (uint32_T)x->size[0]; b_unnamed_idx_1 = (uint32_T)b_b->size[1]; i7 = b_y->size[0] * b_y->size[1]; b_y->size[0] = (int32_T)unnamed_idx_0; emxEnsureCapacity((emxArray__common *)b_y, i7, (int32_T)sizeof(real_T)); i7 = b_y->size[0] * b_y->size[1]; b_y->size[1] = (int32_T)b_unnamed_idx_1; emxEnsureCapacity((emxArray__common *)b_y, i7, (int32_T)sizeof(real_T)); br = (int32_T)unnamed_idx_0 * (int32_T)b_unnamed_idx_1; for (i7 = 0; i7 < br; i7++) { b_y->data[i7] = 0.0; } if ((x->size[0] == 0) || (b_b->size[1] == 0)) { } else { unnamed_idx_1 = x->size[0] * (b_b->size[1] - 1); cr = 0; while ((x->size[0] > 0) && (cr <= unnamed_idx_1)) { i7 = cr + x->size[0]; for (ic = cr; ic + 1 <= i7; ic++) { b_y->data[ic] = 0.0; } cr += x->size[0]; } br = 0; cr = 0; while ((x->size[0] > 0) && (cr <= unnamed_idx_1)) { ar = -1; for (ib = br; ib + 1 <= br + 2; ib++) { if (b_b->data[ib] != 0.0) { ia = ar; i7 = cr + x->size[0]; for (ic = cr; ic + 1 <= i7; ic++) { ia++; b_y->data[ic] += b_b->data[ib] * x->data[ia]; } } ar += x->size[0]; } br += 2; cr += x->size[0]; } } emxFree_real_T(&b_b); emxInit_real_T(&b_a, 2); emxInit_real_T(&r4, 2); unnamed_idx_1 = y->size[0]; cr = x->size[0]; i7 = b_a->size[0] * b_a->size[1]; b_a->size[0] = a->size[0]; b_a->size[1] = unnamed_idx_1; emxEnsureCapacity((emxArray__common *)b_a, i7, (int32_T)sizeof(real_T)); br = a->size[0]; for (i7 = 0; i7 < br; i7++) { for (ar = 0; ar < unnamed_idx_1; ar++) { b_a->data[i7 + b_a->size[0] * ar] = a->data[i7]; } } emxFree_real_T(&a); i7 = r4->size[0] * r4->size[1]; r4->size[0] = cr; r4->size[1] = b->size[1]; emxEnsureCapacity((emxArray__common *)r4, i7, (int32_T)sizeof(real_T)); for (i7 = 0; i7 < cr; i7++) { br = b->size[1]; for (ar = 0; ar < br; ar++) { r4->data[i7 + r4->size[0] * ar] = b->data[b->size[0] * ar]; } } emxFree_real_T(&b); i7 = d->size[0] * d->size[1]; d->size[0] = b_a->size[0]; d->size[1] = b_a->size[1]; emxEnsureCapacity((emxArray__common *)d, i7, (int32_T)sizeof(real_T)); br = b_a->size[1]; for (i7 = 0; i7 < br; i7++) { unnamed_idx_1 = b_a->size[0]; for (ar = 0; ar < unnamed_idx_1; ar++) { d->data[ar + d->size[0] * i7] = (b_a->data[ar + b_a->size[0] * i7] + r4->data[ar + r4->size[0] * i7]) - 2.0 * b_y->data[ar + b_y->size[0] * i7]; } } emxFree_real_T(&r4); emxFree_real_T(&b_a); emxFree_real_T(&b_y); b_sqrt(d); }