void AdaBoost<MatType, WeakLearner>::Classify( const MatType& test, arma::Row<size_t>& predictedLabels) { arma::Row<size_t> tempPredictedLabels(test.n_cols); arma::mat cMatrix(classes, test.n_cols); cMatrix.zeros(); predictedLabels.set_size(test.n_cols); for (size_t i = 0; i < wl.size(); i++) { wl[i].Classify(test, tempPredictedLabels); for (size_t j = 0; j < tempPredictedLabels.n_cols; j++) cMatrix(tempPredictedLabels(j), j) += (alpha[i] * tempPredictedLabels(j)); } arma::colvec cMRow; arma::uword maxIndex; for (size_t i = 0; i < predictedLabels.n_cols; i++) { cMRow = cMatrix.unsafe_col(i); cMRow.max(maxIndex); predictedLabels(i) = maxIndex; } }
void cCritterViewer::setViewpoint(cVector toviewer, cVector lookatpoint, BOOL trytoseewholeworld) { //First do some default setup stuff _fieldofviewangle = cCritterViewer::STARTFIELDOFVIEWANGLE; setSpeed(0.0); #ifndef THREEDVECTORS //not THREEDVECTORS means the 2D case. _attitude = cMatrix(cVector2(1.0, 0.0), cVector2(0.0, 1.0), _position); #else //THREEDVECTORS _attitude = cMatrix(-cVector::ZAXIS, -cVector::XAXIS, cVector::YAXIS, cVector::ZEROVECTOR); /* To get a reasonable default orientation, we arrange the viewer axes so that: viewer x axis = world -z axis, viewer y axis = world -x axis, viewer z axis = world y axis. We pick this orientation so that if the viewer moves "forward" (along its tangent vector) it moves towards the world. (We correct the mismatch between the coordinate systems in the cCritterViewer::loadViewMatrix method, which has a long comment about this.) Note that we will adjust _position (fourth column) later in this call with a moveTo, also we may rotate the _attitude a bit. */ if (!_perspective) //Ortho view, simply move up. { _proportionofworldtoshow = 1.0; //Show all of a flat world. moveTo(lookatpoint + cCritterViewer::ORTHOZOFFSET * cVector::ZAXIS); // Get above the world _maxspeed = _maxspeedstandard = 0.5 * cCritterViewer::ORTHOZOFFSET; //Mimic perspective case. } else //_perspective { if (toviewer.isPracticallyZero()) //Not usable, so pick a real direction. toviewer = cVector::ZAXIS; //Default is straight up. if (trytoseewholeworld) /* Treat toviewer as a direction, and back off in that direction enough to see the whole world */ { toviewer.normalize(); //Make it a unit vector. _proportionofworldtoshow = cCritterViewer::PROPORTIONOFWORLDTOSHOW; //Trying to show all of a world when flying around it, often leaves too big a space around it. Real furthestcornerdistance = pgame()->border().maxDistanceToCorner(lookatpoint); Real tanangle = tan(_fieldofviewangle/2.0); /* We work with half the fov in this calculation, the tanangle will be the ratio of visible distance to distance above the world, that is, tanangle = dr/dz, where Our dr is _proportionofworldtoshow * furthestcornerdistance, and our dz is the unknown seeallz height we need to back off to. Swap tangangle and dz to get the next formula. */ ASSERT(tanangle); Real seeallz = _proportionofworldtoshow * furthestcornerdistance / tanangle; moveTo(lookatpoint + seeallz * toviewer); } else /*Not trytoseewholeworld. In this case we don't normalize toviewer, instead we treat it as a displacment from the lookatpoint. */ moveTo(lookatpoint + toviewer); lookAt(lookatpoint); _maxspeed = _maxspeedstandard = 0.5 * (position()-lookatpoint).magnitude(); /* Define the speed like this so it typically takes two seconds (1/0.5) to fly in to lookatpoint. */ _lastgoodplayeroffset = position() - pgame()->pplayer()->position(); } #endif //THREEDVECTORS case }
DLLEXPORT void vclGemm(const BlasTranspose transA, const BlasTranspose transB, const int m, const int n, const int k, const ScalarType alpha, const ScalarType a[], const int aOffset, const ScalarType b[], const int bOffset, const float beta, ScalarType c[], const int cOffset) { auto aPtr = &(a[0]) + aOffset; auto bPtr = &(b[0]) + bOffset; auto cPtr = &(c[0]) + cOffset; int lda = transA == BlasTranspose::None ? m : k; int ldb = transB == BlasTranspose::None ? k : n; int aSize1 = (transA == BlasTranspose::Transpose) ? k : m; int aSize2 = (transA == BlasTranspose::Transpose) ? m : k; int bSize1 = (transB == BlasTranspose::Transpose) ? n : k; int bSize2 = (transB == BlasTranspose::Transpose) ? k : n; viennacl::matrix<ScalarType> aMatrix((ScalarType*)aPtr, viennacl::MAIN_MEMORY, aSize1, aSize2); viennacl::matrix<ScalarType> bMatrix((ScalarType*)bPtr, viennacl::MAIN_MEMORY, bSize1, bSize2); viennacl::matrix<ScalarType> cMatrix(cPtr, viennacl::MAIN_MEMORY, m, n); };
void FloodPlotColorMap::init() { /// set color stops /// scale between 0 and 1 unsigned int colormapLength = m_colorLevels.size(); // start and end colors int r, g, b; unsigned int i,j; QColor minColor, maxColor; // colors at interval ends double min = openstudio::minimum(m_colorLevels); double max = openstudio::maximum(m_colorLevels); if (max == min) { return; } switch (m_colorMap) { case Gray: double gray; minColor = QColor(0,0,0); maxColor = QColor(255,255,255); setColorInterval(minColor, maxColor); // end points for (i = 0; i < colormapLength; i++) { gray = 1.0 * i / (colormapLength - 1); r = (int)(255 * gray); g = (int)(255 * gray); b = (int)(255 * gray); addColorStop( (m_colorLevels(i) - min) / (max - min), QColor(r, g, b)); } break; case Jet: Matrix cMatrix(colormapLength,3); unsigned int n = (int)ceil(colormapLength / 4.0); int nMod = 0; Vector fArray(3 * n - 1); Vector red(fArray.size()); Vector green(fArray.size()); Vector blue(fArray.size()); for (i = 0; i < colormapLength; i++) { cMatrix(i, 0) = 0; cMatrix(i, 1) = 0; cMatrix(i, 2) = 0; } if (colormapLength % 4 == 1) { nMod = 1; } for (i = 0; i <fArray.size(); i++) { if (i < n) fArray(i) = (float)(i + 1) / n; else if (i >= n && i < 2 * n - 1) fArray(i) = 1.0; else if (i >= 2 * n - 1) fArray(i) = (float)(3 * n - 1 - i) / n; green(i) = (int)ceil(n / 2.0) - nMod + i; red(i) = green(i) + n; blue(i) = green(i) - n; } int nb = 0; for (i = 0; i < blue.size(); i++) { if (blue(i) > 0) nb++; } for (i = 0; i < colormapLength; i++) { for (j = 0; j < red.size(); j++) { if (i == red(j) && red(j) < colormapLength) { cMatrix(i, 0) = fArray(i - red(0)); } } for (j = 0; j < green.size(); j++) { if (i == green(j) && green(j) < colormapLength) cMatrix(i, 1) = fArray(i - (int)green(0)); } for ( j = 0; j < blue.size(); j++) { if (i == blue(j) && blue(j) >= 0) cMatrix(i, 2) = fArray(fArray.size() - 1 - nb + i); } } // set before adding color stops // default from http://www.matthiaspospiech.de/blog/2008/06/16/qwt-spectrogramm-plot-with-data-arrays/ minColor = QColor(0,0,189); maxColor = QColor(132,0,0); int bMin=256; int rMin=256; for (i = 0; i < colormapLength; i++) { r = (int)(cMatrix(i, 0) * 255); g = (int)(cMatrix(i, 1) * 255); b = (int)(cMatrix(i, 2) * 255); if ((r==0) && (g==0) && (b<bMin)) { bMin=b; minColor = QColor(r,g,b); } if ((b==0) && (g==0) && (r<rMin)) { rMin=r; maxColor = QColor(r,g,b); } } setColorInterval(minColor, maxColor); // end points for (i = 0; i < colormapLength; i++) { r = (int)(cMatrix(i, 0) * 255); g = (int)(cMatrix(i, 1) * 255); b = (int)(cMatrix(i, 2) * 255); addColorStop( (m_colorLevels(i) - min) / (max - min), QColor(r, g, b)); } break; } }
// matrix multiplication XSQUARE_MATRIX XSQUARE_MATRIX::operator *(const XSQUARE_MATRIX &i_cRHO) const { XSQUARE_MATRIX cMatrix(*this); cMatrix *= i_cRHO; return cMatrix; }
//------------------------------------------------------------------------------ void MfLowRankApproximation::initialize() { double dx; double constValue; double endValue; double constEnd; double epsilon; dx = grid.DX; try { nOrbitals = cfg->lookup("spatialDiscretization.nSpatialOrbitals"); constEnd = cfg->lookup("meanFieldIntegrator.lowRankApproximation.constEnd"); constValue = cfg->lookup("meanFieldIntegrator.lowRankApproximation.constValue"); endValue = cfg->lookup("meanFieldIntegrator.lowRankApproximation.endValue"); epsilon = cfg->lookup("meanFieldIntegrator.lowRankApproximation.epsilon"); } catch (const SettingNotFoundException &nfex) { cerr << "MfLowRankApproximation::Error reading entry from config object." << endl; exit(EXIT_FAILURE); } int nConst = constEnd/dx; int constCenter = nGrid/2; Vxy = zeros(nGrid, nGrid); for(uint p=0; p<potential.size(); p++) { for(int i=0; i<nGrid; i++) { for(int j=0; j<nGrid; j++) { Vxy(i, j) += potential[p]->evaluate(i, j); } } } // Using a simple discretization equal to the discretization of // the system. mat h = hExactSpatial(); // mat h = hPiecewiseLinear(); mat Q = eye(nGrid,nGrid); // Using a consant weight in the center of the potential // and a linear decrease from the center. vec g = gLinear(nGrid, constCenter, nConst, constValue, endValue); mat C = cMatrix(g, h, dx); vec lambda; mat eigvec; eig_sym(lambda, eigvec, inv(C.t())*Vxy*inv(C)); mat Ut = C.t()*eigvec; mat QU = inv(Q)*Ut; // Sorting the eigenvalues by absoulte value and finding the number // of eigenvalues with abs(eigenval(i)) > epsilon uvec indices = sort_index(abs(lambda), 1); M = -1; for(uint m=0; m <lambda.n_rows; m++) { cout << abs(lambda(indices(m))) << endl; if(abs(lambda(indices(m))) < epsilon) { M = m; break; } } // cout << min(abs(lambda)) << endl; // cout << "hei" << endl; // cout << lambda << endl; // M = 63; if(M < 0) { cerr << "MfLowRankApproximation:: no eigenvalues < epsilon found." << " Try setting epsilon to a higher number" << endl; exit(EXIT_FAILURE); } eigenval = zeros(M); for(int m=0; m <M; m++) { eigenval(m) = lambda(indices(m)); } // Calculating the U matrix U = zeros(nGrid, M); for(int m=0; m < M; m++) { for(uint j=0; j<h.n_rows; j++) { U(j,m) = 0; for(uint i=0; i<h.n_cols; i++) { U(j,m) += h(j,i)*QU(i,indices(m)); } } } cout << "MfLowRankApproximation:: Trunction of eigenvalues at M = " << M << endl; #if 1 // For testing the low rank approximation's accuracy mat appV = zeros(nGrid, nGrid); for(int i=0; i<nGrid; i++) { for(int j=0; j<nGrid; j++) { appV(i,j) = 0; for(int m=0; m<M; m++) { appV(i,j) += eigenval(m)*U(i,m)*U(j,m); } } } mat diffV = abs(Vxy - appV); cout << "max_err = " << max(max(abs(Vxy - appV))) << endl; diffV.save("../DATA/diffV.mat"); appV.save("../DATA/Vapp.mat"); Vxy.save("../DATA/Vex.mat"); cout << nGrid << endl; // exit(EXIT_SUCCESS); #endif cout << "test" << endl; Vm = zeros<cx_vec>(M); Vqr = zeros<cx_vec>(nGrid); }