VECTOR CTempConvs::dotdiv(VECTOR& a, VECTOR& b) { ///* VECTOR div(a.size()); for (int i = 0; i < (int)a.size(); i++) { // Armadillo elementwise division gives NaN for 0/0 if ((a(i) == 0)) div(i) = 0; else if (b(i) == 0) div(i) = INF; else div(i) = a(i) / b(i); } //*/ // Alternatively, the following gives identicle results to Matlab /* VECTOR div(a.size()); for (int i = 0; i<(int)a.size(); i++){ div(i) = 0; } if (a.size() != b.size()) return div; for (int i = 0; i<(int)a.size(); i++) { if (a(i) == NaN) div(i) = NaN; if (a(i) == INF) { if (b(i) == INF || b(i) == NaN) div(i) = NaN; else div(i) = INF; } if (a(i) == 0) { if (b(i) != 0 || b(i) == INF) div(i) = 0; else div(i) = NaN; } else { if (b(i) == 0 || b(i) == NaN) div(i) = NaN; if (b(i) == INF) div(i) = 0; else div(i) = a(i) / b(i); } } //*/ //a.print("a:"); b.print("b:"); div.print("div:"); return div; }
void Backpropagation::trainOnlineCV(Mlp& network, MATRIX& trainingInputs, VECTOR& trainingTargets, MATRIX& testInputs, VECTOR& testTargets) { VECTOR trainingOutputs(trainingTargets.size(), 0.0); VECTOR testOutputs(testTargets.size(), 0.0); while(error > tolerance && testCount < maxTestCount) { VECTOR::iterator output = trainingOutputs.begin(); VECTOR::iterator target = trainingTargets.begin(); for(MATRIX::iterator input = trainingInputs.begin(); input != trainingInputs.end(); ++input, ++target, ++output) { *output = network(*input); double err = *output - *target; getWeightUpdates(network, *input, err); applyWeightUpdates(network); ++iteration; if(iteration >= maxIterations) break; } ++epoch; error = mse(trainingTargets, trainingOutputs); // Early-stopping using test (cross-validation) error testOutputs = network(testInputs); testError = mse(testTargets, testOutputs); if(testError < minTestError) { // Preserve test error and network weights minTestError = testError; W = network.W; V = network.V; biasW = network.biasW; biasV = network.biasV; testCount = 0; } else { ++testCount; } } network.W = W; network.V = V; network.biasW = biasW; network.biasV = biasV; testError = minTestError; }
////////////////////////////////////////////////////////////////////// // scale a vector ////////////////////////////////////////////////////////////////////// VECTOR operator*(const Real& scalar, const VECTOR& x) { VECTOR z(x.size()); for (int i = 0; i < x.size(); i++) //z(i) = x(i) * scalar; z(i) = x[i] * scalar; return z; }
////////////////////////////////////////////////////////////////////// // subtract two vectors ////////////////////////////////////////////////////////////////////// VECTOR operator-(const VECTOR& x, const VECTOR& y) { VECTOR z(x.size()); for (int i = 0; i < x.size(); i++) //z(i) = x(i) - y(i); z(i) = x[i] - y[i]; return z; }
////////////////////////////////////////////////////////////////////// // compute the 2 norm ////////////////////////////////////////////////////////////////////// Real operator^(const VECTOR& x, const VECTOR& y) { assert(x.size() == y.size()); #if __APPLE__ #ifdef SINGLE_PRECISION return cblas_sdot (x.size(), x.dataConst(), 1, y.dataConst(), 1); #else return cblas_ddot (x.size(), x.dataConst(), 1, y.dataConst(), 1); #endif #else return x * y; #endif }
bool CheckEqualVector( const VECTOR& rActualVector , const VECTOR& rExpectedVector) { // Check that the two array are of equal length auto ret = rActualVector.size() == rExpectedVector.size(); if (ret) { for (auto i = 0u; i < rExpectedVector.size(); ++i) { ret = ret && rActualVector[i] == rExpectedVector[i]; if (!ret) break; } } else { std::cout << "Vectors have different size!" << std::endl; } return ret; }
/** * Re-order a vector of labels according to the permutation. * perm[i] = k means that label L(i) initially at position i must be put at pos k. * * see getPermute() for the opposite transformation. **/ template<typename VECTOR> VECTOR getAntiPermute(const VECTOR & labels) const { const size_t l = labels.size(); MTOOLS_INSURE(_perm.size() == l); VECTOR res(l); for (size_t i = 0; i < l; i++) { res[_perm[i]] = labels[i]; } return res; }
////////////////////////////////////////////////////////////////////// // Vector-matrix multiply ////////////////////////////////////////////////////////////////////// VECTOR operator*(VECTOR& x, MATRIX& A) { assert(A.rows() == x.size()); VECTOR y(A.cols()); for (int i = 0; i < A.cols(); i++) for (int j = 0; j < A.rows(); j++) y[i] += A(j, i) * x(j); return y; }
bool CheckCloseVector( const VECTOR& rActualVector , const VECTOR& rExpectedVector , double delta) { // Check that the two array are of equal length auto ret = rActualVector.size() == rExpectedVector.size(); if (ret) { for (auto i = 0u; i < rExpectedVector.size(); ++i) { ret = ret && std::abs(rActualVector[i] - rExpectedVector[i]) <= std::abs(rExpectedVector[i]) * delta; if (!ret) break; } } else { std::cout << "Vectors have different size!" << std::endl; } return ret; }
bool is_sorted_and_unique(const VECTOR& vec, COMPARE compare) { bool sorted_and_unique = true; for(size_t i=1; i<vec.size(); ++i) { if (!compare(vec[i-1],vec[i])) { sorted_and_unique = false; } } return sorted_and_unique; }
// Calculate equal categories void MgFeatureNumericFunctions::GetEqualCategories(VECTOR &values, int numCats, double dataMin, double dataMax, VECTOR &distValues) { // Expected categories should be more than zero if (numCats <= 0) { STRING message = MgServerFeatureUtil::GetMessage(L"MgInvalidComputedProperty"); MgStringCollection arguments; arguments.Add(message); throw new MgFeatureServiceException(L"MgServerSelectFeatures.GetEqualCategories", __LINE__, __WFILE__, &arguments, L"", NULL); } // find the range of the data values double min = DoubleMaxValue; double max = -DoubleMaxValue; int cnt = (int)values.size(); if (cnt <= 0) { return; } // Nothing to do, we just send back Property Definition to clients from reader for (int i=0; i < cnt; i++) { double val = values[i]; if (val > max) max = val; if (val < min) min = val; } // expand the range a little to account for numerical instability double delta = 0.0001 * (max - min); min -= delta; max += delta; // but don't let the values extend beyond the data min/max if (min < dataMin) min = dataMin; if (max > dataMax) max = dataMax; // This method ignores dataMin and dataMax. A different "Equal" distribution // might ignore the actual data values and create categories based on dataMin // and dataMax when those values are not +/- infinity. // fill in the categories distValues.push_back(min); delta = (max - min) / (double)numCats; for (int i=1; i<numCats; i++) { double nextval = distValues[i-1] + delta; distValues.push_back(nextval); } distValues.push_back(max); }
VECTOR<TYPE>::VECTOR(const VECTOR& copy) { VECTOR(); if(this != ©) { this->reserve(copy.capacity()); for(unsigned int i = 0; i < copy.size(); i++) { this->mpData[i] = copy[i]; } } }
void unwrap2PiSequence(VECTOR &x) { const size_t N=x.size(); for (size_t i=0;i<N;i++) { mrpt::math::wrapToPiInPlace(x[i]); // assure it's in the -pi,pi range. if (!i) continue; double Ap = x[i]-x[i-1]; if (Ap>M_PI) x[i]-=2.*M_PI; if (Ap<-M_PI) x[i]+=2.*M_PI; } }
Vec RQR_Multiply(const VECTOR &v, const SparseKalmanMatrix &RQR, const SparseVector &Z, double H) { int state_dim = Z.size(); if(v.size() != state_dim + 2) { report_error("wrong sizes in RQR_Multiply"); } // Partition v = [eta, epsilon, 0] ConstVectorView eta(v, 0, state_dim); double epsilon = v[state_dim]; // Partition this Vec RQRZ = RQR * Z.dense(); double ZRQRZ_plus_H = Z.dot(RQRZ) + H; Vec ans(v.size()); VectorView(ans, 0, state_dim) = (RQR * eta).axpy(RQRZ, epsilon); ans[state_dim] = RQRZ.dot(eta) + ZRQRZ_plus_H * epsilon; return ans; }
// Calculate Standard Deviation for the values void MgFeatureNumericFunctions::GetStandardDeviation(VECTOR &values, VECTOR &distValues) { double mean = 0; int cnt = (int)values.size(); if (cnt <= 0) { return; } // Nothing to do, we just send back Property Definition to clients from reader double min = DoubleMaxValue; double max = -DoubleMaxValue; for (int i=0; i < cnt; i++) { double val = values[i]; if (val > max) max = val; if (val < min) min = val; mean += val; } // expand min and max a little to account for numerical instability double delta = 0.0001 * (max - min); min -= delta; max += delta; // compute the mean, variance and standard deviation double count = (double)cnt; // (guaranteed to be > 0) mean /= count; double variance = 0; for (int i=0; i < cnt; i++) { variance += (values[i] - mean) * (values[i] - mean); } double deviation = sqrt((double)(variance / count)); // Set the base date as min date if (m_type == MgPropertyType::DateTime) { deviation += min; } distValues.push_back(deviation); return; }
void TridiagonalMatrix<C>::apply_transposed(const VECTOR& x, VECTOR& Mtx) const { assert(Mtx.size() == rowdim_); for (typename TridiagonalMatrix<C>::size_type i(0); i < rowdim_; i++) { Mtx[i] = b_[i] * x[i]; if (i > 0) Mtx[i] += c_[i-1] * x[i-1]; if (i+1 < rowdim_) Mtx[i] += a_[i] * x[i+1]; } }
void Backpropagation::trainBatch(Mlp& network, MATRIX& trainingInputs, VECTOR& trainingTargets, MATRIX& testingInputs, VECTOR& testingTargets) { VECTOR trainingOutputs (trainingTargets.size(), 0.0); VECTOR meanInput = ave(trainingInputs); while (epoch < maxEpochs) { trainingOutputs = network(trainingInputs); error = sse(trainingOutputs, trainingTargets); getWeightUpdates(network, meanInput, error); applyWeightUpdates(network); ++epoch; } }
////////////////////////////////////////////////////////////////////// // sparse matrix-vector multiply ////////////////////////////////////////////////////////////////////// VECTOR operator*(const SPARSE_MATRIX& A, const VECTOR& x) { assert(A.cols() == x.size()); VECTOR y(A.rows()); // iterate through all the entries map<pair<int,int>, Real>::const_iterator iter; const map<pair<int,int>, Real>& data = A.matrix(); for (iter = data.begin(); iter != data.end(); iter++) { const pair<int,int> index = iter->first; const Real value = iter->second; int i = index.first; int j = index.second; y(i) += x[j] * value; } return y; }
// Calculate average void MgFeatureNumericFunctions::GetMeanValue(VECTOR &values, VECTOR &distValues) { double mean = 0; int cnt = (int)values.size(); if (cnt <= 0) { return; } // Nothing to do, we just send back Property Definition to clients from reader for (int i=0; i < cnt; i++) { double val = values[i]; mean += val; } // compute the mean, variance and standard deviation double count = (double)cnt; // (guaranteed to be > 0) mean /= count; distValues.push_back(mean); return; }
void Backpropagation::trainOnline(Mlp& network, MATRIX& inputs, VECTOR& targets) { VECTOR outputs(targets.size(), 0.0); while(iteration < maxIterations) { VECTOR::iterator output = outputs.begin(); VECTOR::iterator target = targets.begin(); for(MATRIX::iterator input = inputs.begin(); input != inputs.end(); ++input, ++target, ++output) { *output = network(*input); double err = *output - *target; getWeightUpdates(network, *input, err); applyWeightUpdates(network); ++iteration; } ++epoch; } }
int main() { QFile prj(":prj/barracks-scaled11-elements.prj"); bool ignoreSystemZones = true; bool ignoreAmbientZone = true; std::cout << "Opening file... "; if(!prj.open(QFile::ReadOnly)) { std::cout << " failed." << std::endl; return EXIT_FAILURE; } std::cout << " succeeded." << std::endl << std::endl; QTextStream stream(&prj); prj::Reader input(&stream); prj::Model airflowModel(input); std::cout << "CONTAM version: " + airflowModel.version() << std::endl; std::cout << "SketchPad dimensions: " << airflowModel.skwidth() << " cells by " << airflowModel.skheight() << " cells" << std::endl; std::cout << "SketchPad scale: " << TO_STRING(airflowModel.scale()) << " m" <<std::endl; std::cout << "SketchPad scale: " << TO_STRING(airflowModel.scale()) << " m" <<std::endl; std::cout << "Active contaminants: " << airflowModel.contaminants().size() << std::endl; for(unsigned int i=0;i<airflowModel.contaminants().size();i++) { int nr = airflowModel.contaminants()[i]; std::cout << '\t' << nr << ": " << airflowModel.species()[nr-1].name() << std::endl; } std::cout << std::endl << "Day schedules: " << airflowModel.daySchedules().size() << std::endl; std::cout << std::endl << "Week schedules: " << airflowModel.weekSchedules().size() << std::endl; std::cout << std::endl << "Wind pressure profiles: " << airflowModel.windPressureProfiles().size() << std::endl; for(unsigned int i=1;i<=airflowModel.windPressureProfiles().size();i++) { std::cout << '\t' << i << ": " << airflowModel.windPressureProfiles()[i-1].name() << std::endl; } VECTOR<prj::Path> paths = airflowModel.paths(); std::cout << std::endl << "Paths: " << paths.size() << std::endl; QFile fp("prj.dot"); if (fp.open(QFile::WriteOnly)) { QTextStream stream(&fp); stream << "graph {\n"; for(unsigned int i=0;i<paths.size();i++) { int pzm = paths[i].pzm(); int pzn = paths[i].pzn(); if(pzm<0) { if(ignoreAmbientZone) { continue; } pzm=0; } if(ignoreSystemZones && airflowModel.zones()[pzm-1].system()) { continue; } if(pzn<0) { if(ignoreAmbientZone) { continue; } pzn=0; } if(ignoreSystemZones && airflowModel.zones()[pzn-1].system()) { continue; } stream << pzn << " -- " << pzm << '\n'; } stream << "}"; } fp.close(); /* VECTOR<prj::CvfDat> cvf = airflowModel.getCvfDat(); std::cout << std::endl << "CvfDat elements: " << cvf.size() << std::endl; for(unsigned int i=0;i<cvf.size();i++) { std::cout << '\t' << i+1 << ": " << cvf[i].name() << std::endl; } std::cout << std::endl << "Simple air handling systems: " << airflowModel.ahs().size() << std::endl; for(unsigned int i=1;i<=airflowModel.ahs().size();i++) { std::cout << '\t' << i << ": " << airflowModel.ahs()[i-1].name() << std::endl; } VECTOR<prj::Zone> zones = airflowModel.zones(); std::cout << std::endl << "Zones: " << zones.size() << std::endl; for(unsigned int i=0;i<zones.size();i++) { std::cout << '\t' << i+1 << ": " << zones[i].name() << std::endl; } */ std::cout << std::endl << "Done." << std::endl; //std::cout << airflowModel.toString(); //prj::PlrTest1 plr; //plr.setName("TEST"); //airflowModel.addAirflowElement(plr); /* QFile fp("out.prj"); if (fp.open(QFile::WriteOnly)) { QTextStream stream(&fp); stream << QString().fromStdString(airflowModel.toString()); fp.close(); } else { std::cout << "Failed to write 'out.prj'" << std::endl; return EXIT_FAILURE; } */ return EXIT_SUCCESS; }
Estimator2D<Mahalanobis2D>::Estimator2D(const VECTOR& X, const VECTOR& Y) : X_(&X), Y_(&Y) { setBandwidth(scottBandwidth(X.size(), 2.0, 1.0)); setCovariance(var(X), var(Y), covar(X, Y)); }
void SystematicSampler::sortKey(VECTOR x) { sortedKey_ = std::sequence<unsigned> (0, x.size()); std::sort(x, sortedKey_); }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Vector_Test")); VECTOR vector; size_t i; for (i = 0; i < TOP; ++i) vector.push_back (i); ACE_TEST_ASSERT (vector.size () == TOP); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Size: %d\n"), vector.size ())); for (i = 0; i < TOP; ++i) ACE_TEST_ASSERT (vector[i] == i); // Test to be sure the iterator gets the correct count and entries. ITERATOR iter (vector); DATA *p_item = 0 ; size_t iter_count = 0; while (!iter.done ()) { if (iter.next (p_item) == 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Fail to get value on iter pass %d\n"), iter_count)); if (*p_item != iter_count) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Iter pass %d got %d\n"), iter_count, *p_item)); iter_count++; iter.advance(); } if (iter_count != TOP) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Iterated %d elements; expected %d\n"), iter_count, TOP)); for (i = 0; i < (TOP - LEFT); ++i) vector.pop_back (); ACE_TEST_ASSERT (vector.size () == LEFT); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Size: %d\n"), vector.size ())); for (i = 0; i < LEFT; ++i) { ACE_TEST_ASSERT (vector[i] == i); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("vector[%d]:%d\n"), i, vector[i])); } vector.resize(RESIZE, 0); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("After resize\n"))); for (i = 0; i < RESIZE ; ++i) { // The original vector of size LEFT must have the same original contents // the new elements should have the value 0 (this value is passed as // second argument of the resize() call. if (i < LEFT) { ACE_TEST_ASSERT (vector[i] == i); } else { ACE_TEST_ASSERT (vector[i] == 0); } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("vector[%d]:%d\n"), i, vector[i])); } vector.clear (); ACE_TEST_ASSERT (vector.size () == 0); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Size: %d\n"), vector.size ())); // test resize (shrink and enlarge with buffer realloc) VECTOR vector2; // should be around 32 size_t boundary = vector2.capacity (); // we fill everything up with 1 // 1, 1, 1, 1, 1, 1, 1, 1, // 1, 1, 1, 1, 1, 1, 1, 1, // 1, 1, 1, 1, 1, 1, 1, 1, // 1, 1, 1, 1, 1, 1, 1, 1, for (i = 0; i < boundary; ++i) vector2.push_back (FILLER1); // we throw almost everything away. vector2.resize (1, 0); // we fill up with another pattern // 1, 2, 2, 2, 2, 2, 2, 2, // 2, 2, 2, 2, 2, 2, 2, 2, // 2, 2, 2, 2, 2, 2, 2, 2, // 2, 2, 2, 2, 2, 2, 2, 2, // 2, for (i = 0; i < boundary; ++i) vector2.push_back (FILLER2); // now we check the result ACE_TEST_ASSERT (vector2[0] == FILLER1); for (i = 0; i < boundary; ++i) ACE_TEST_ASSERT (vector2[i+1] == FILLER2); VECTOR v1; VECTOR v2; v1.push_back (1); v2.push_back (1); v1.push_back (2); v2.push_back (2); if (v1 != v2) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Inequality test failed!\n"))); if (!(v1 == v2)) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Equality test failed!\n"))); v1.push_back (3); if (v1.size () != 3) ACE_ERROR ((LM_ERROR, ACE_TEXT ("v1's size should be 3\n"))); v1.swap (v2); if (v2.size () != 3) ACE_ERROR ((LM_ERROR, ACE_TEXT ("v2's size should be 3\n"))); ACE_END_TEST; return 0; }
////////////////////////////////////////////////////////////////////// // Output directly to the files that will be sent to SVD ////////////////////////////////////////////////////////////////////// void FLUID_3D_MIC::appendStreams() const { TIMER functionTimer(__FUNCTION__); assert(_snapshotPath.size() > 0); cout << " Appending to streams in path " << _snapshotPath.c_str() << " ... " << flush; vector<int> finalRows(6); vector<int> finalCols(6); // read in the initial file dims vector<string> filenames; filenames.push_back(_snapshotPath + string("velocity.final.matrix.dims")); filenames.push_back(_snapshotPath + string("velocity.preproject.matrix.dims")); filenames.push_back(_snapshotPath + string("velocity.prediffuse.matrix.dims")); filenames.push_back(_snapshotPath + string("velocity.preadvect.matrix.dims")); filenames.push_back(_snapshotPath + string("velocity.iop.matrix.dims")); filenames.push_back(_snapshotPath + string("pressure.matrix.dims")); for (int x = 0; x < filenames.size(); x++) { FILE* dimsFile = fopen(filenames[x].c_str(), "rb"); if (dimsFile == NULL) continue; int rows, cols; // write dimensions fread((void*)&rows, sizeof(int), 1, dimsFile); fread((void*)&cols, sizeof(int), 1, dimsFile); fclose(dimsFile); finalRows[x] = rows; finalCols[x] = cols; } FILE* fileFinal; FILE* filePreproject; FILE* filePrediffuse; FILE* filePreadvect; FILE* fileIOP; FILE* fileNeumannIOP; FILE* filePressure; string velocityFinalFile = _snapshotPath + string("velocity.final.matrix.transpose"); string velocityPreprojectFile = _snapshotPath + string("velocity.preproject.matrix.transpose"); string velocityPrediffuseFile = _snapshotPath + string("velocity.prediffuse.matrix.transpose"); string velocityPreadvectFile = _snapshotPath + string("velocity.preadvect.matrix.transpose"); string velocityIOPFile = _snapshotPath + string("velocity.iop.matrix.transpose"); string neumannIOPFile = _snapshotPath + string("neumann.iop.matrices"); string pressureFile = _snapshotPath + string("pressure.matrix.transpose"); // if there's a Neumann matrix at all, it's using IOP bool usingIOP = (_neumannIOP.rows() > 0); fileFinal = fopen(velocityFinalFile.c_str(), "ab"); filePreproject = fopen(velocityPreprojectFile.c_str(), "ab"); filePrediffuse = fopen(velocityPrediffuseFile.c_str(), "ab"); filePreadvect = fopen(velocityPreadvectFile.c_str(), "ab"); fileIOP = fopen(velocityIOPFile.c_str(), "ab"); if (usingIOP) fileNeumannIOP = fopen(neumannIOPFile.c_str(), "ab"); filePressure = fopen(pressureFile.c_str(), "ab"); VECTOR velocity = _velocity.peelBoundary().flattened(); int cols = velocity.size(); assert(cols % 3 == 0); int scalarCols = cols / 3; // set the rows and cols, in case this is the first time for (int x = 0; x < 5; x++) if (finalCols[x] == 0) finalCols[x] = cols; if (finalCols[5] == 0) finalCols[5] = scalarCols; if (velocity.norm2() > 1e-7) { fwrite((void*)(velocity.data()), sizeof(double), cols, fileFinal); finalRows[0]++; } velocity = _preprojection.peelBoundary().flattened(); if (velocity.norm2() > 1e-7) { fwrite((void*)(velocity.data()), sizeof(double), cols, filePreproject); finalRows[1]++; } velocity = _prediffusion.peelBoundary().flattened(); if (velocity.norm2() > 1e-7) { fwrite((void*)(velocity.data()), sizeof(double), cols, filePrediffuse); finalRows[2]++; } velocity = _preadvection.peelBoundary().flattened(); if (velocity.norm2() > 1e-7) { fwrite((void*)(velocity.data()), sizeof(double), cols, filePreadvect); finalRows[3]++; } if (usingIOP) { velocity = _postIOP.peelBoundary().flattened(); if (velocity.norm2() > 1e-7) { fwrite((void*)(velocity.data()), sizeof(double), cols, fileIOP); finalRows[4]++; } } VECTOR scalar = _pressure.peelBoundary().flattened(); if (scalar.norm2() > 1e-7) { fwrite((void*)(scalar.data()), sizeof(double), scalarCols, filePressure); finalRows[5]++; } scalar = _divergence.peelBoundary().flattened(); if (scalar.norm2() > 1e-7) { fwrite((void*)(scalar.data()), sizeof(double), scalarCols, filePressure); finalRows[5]++; } if (usingIOP) _neumannIOP.write(fileNeumannIOP); fclose(fileFinal); fclose(filePreproject); fclose(filePrediffuse); fclose(filePreadvect); fclose(fileIOP); if (usingIOP) fclose(fileNeumannIOP); fclose(filePressure); // write out the dimensions of the matrix to a different file for (int x = 0; x < filenames.size(); x++) { FILE* dimsFile = fopen(filenames[x].c_str(), "wb"); // write dimensions fwrite((void*)&finalRows[x], sizeof(int), 1, dimsFile); fwrite((void*)&finalCols[x], sizeof(int), 1, dimsFile); fclose(dimsFile); } cout << " done. " << endl; }
//------------------------------------------------------------------------- // Jenks' Optimization Method // //------------------------------------------------------------------------- void MgFeatureNumericFunctions::GetJenksCategories( VECTOR &inputData, int numPartsRequested, double dataMin, double dataMax, VECTOR &distValues ) { // numPartsRequested // 2 - 10; 5 is good int i = 0; // index for numObservations (may be very large) int j = 0; // index for numPartsRequested (about 4-8) int k = 0; // Sort the data values in ascending order std::sort(inputData.begin(), inputData.end()); int numObservations = (int)inputData.size(); // may be very large // Possible improvement: Rework the code to use normal 0 based arrays. // Actually it doesn't matter much since we have to create two // matrices that themselves use more memory than the local copy // of inputData. // // In order to ease the use of original FORTRAN and the later BASIC // code, I will use 1 origin arrays and copy the inputData into // a local array; // I'll dimension the arrays one larger than necessary and use the // index values from the original code. // // The algorithm must calculate with floating point values. // If more optimization is attempted in the future, be aware of // problems with calculations using mixed numeric types. std::vector<double> data; data.push_back(0); // dummy value at index 0 std::copy(inputData.begin(), inputData.end(), std::back_inserter(data)); // copy from parameter inputData so that data index starts from 1 // Note that the Matrix constructors initialize all values to 0. // mat1 contains integer values used for indices into data // mat2 contains floating point values of data and bigNum MgMatrix<int> mat1(numObservations + 1, numPartsRequested + 1); MgMatrix<double> mat2(numObservations + 1, numPartsRequested + 1); // const double bigNum = 1e+14; // from original BASIC code; // const double bigNum = std::numeric_limits<double>::max(); const double bigNum = DBL_MAX; // compiler's float.h for (i = 1; i <= numPartsRequested; ++i) { mat1.Set(1, i, 1); for (j = 2; j <= numObservations; ++j) { mat2.Set(j, i, bigNum); } } std::vector<int> classBounds; classBounds.push_back(-2); // dummy value for (i = 1; i <= numPartsRequested; ++i) { classBounds.push_back(-1); } for (int L = 2; L <= numObservations; ++L) { double s1 = 0; double s2 = 0; double v = 0; int w = 0; for (int m = 1; m <= L; ++m) { int i3 = L - m + 1; double val = data[i3]; s2 += (double(val) * double(val)); // if datatype of val is ever allowed to be same as template // parameter T, make sure multiplication is done in double. s1 += val; ++w; v = s2 - ((s1 * s1) / w); int i4 = i3 - 1; if (i4 > 0) { for (j = 2; j <= numPartsRequested; ++j) { double tempnum = v + mat2.Get(i4, j - 1); if (double(mat2.Get(L, j)) >= tempnum) { mat1.Set(L, j, i3); mat2.Set(L, j, tempnum); } } } } mat1.Set(L, 1, 1); mat2.Set(L, 1, v); } k = numObservations; for (j = numPartsRequested; j >= 1; --j) { if (k >= 0 && k <= numObservations) { classBounds[j] = mat1.Get(k, j); k = mat1.Get(k, j) - 1; } } std::vector<int> indices; indices.push_back(0); for (i = 2; i <= numPartsRequested; ++i) { int index = classBounds[i] - 1; if (index > indices.back()) { indices.push_back(index); } } FixGroups(inputData, indices); double val = 0.0; int index = 0; int totIndex = (int)indices.size(); for (int i = 1; i < totIndex; ++i) { index = indices[i] - 1; val = inputData[index]; distValues.push_back(val); } index = numObservations - 1; val = inputData[index]; distValues.push_back(val); int retCnt = (int)distValues.size(); int inCnt = (int)inputData.size(); if (retCnt > 0 && inCnt > 0) { if (!doubles_equal(distValues[0],inputData[0])) { distValues.insert(distValues.begin(), inputData[0]); } } return; }
// Calculate Quantile Distribution for the values void MgFeatureNumericFunctions::GetQuantileCategories( VECTOR &values, int numCats, double dataMin, double dataMax, VECTOR &distValues ) { // Expected categories should be more than zero if (numCats <= 0) { STRING message = MgServerFeatureUtil::GetMessage(L"MgInvalidComputedProperty"); MgStringCollection arguments; arguments.Add(message); throw new MgFeatureServiceException(L"MgServerSelectFeatures.GetEqualCategories", __LINE__, __WFILE__, &arguments, L"", NULL); } int count = (int)values.size(); if (count <= 0) { return; } // Nothing to do, we just send back Property Definition to clients from reader // Sort the data values in ascending order std::sort(values.begin(), values.end()); // How many go into each full bucket? int perBucket = ROUND((double)count/(double)numCats); if (perBucket * numCats > count) perBucket--; // How many buckets are full, and how many are missing one? int nearlyFullBuckets = numCats - (count - perBucket * numCats); int fullBuckets = numCats - nearlyFullBuckets; // expand min and max a little to account for numerical instability double delta = 0.0001 * (values[count-1] - values[0]); double* categories = new double[numCats+1]; // the first and last categories are limited by the data method limits categories[0] = values[0] - delta; if (categories[0] < dataMin) categories[0] = dataMin; categories[numCats] = values[count-1] + delta; if (categories[numCats] > dataMax) categories[numCats] = dataMax; // Mix full and nearly-full buckets to fill in the categories between the ends. int indexOfLast = -1; for ( int i = 1; i<numCats; i++) { bool doingSmallBucket = (nearlyFullBuckets > fullBuckets); // find the index of the last element we want in this bucket indexOfLast += (doingSmallBucket ? perBucket : perBucket + 1); // make category value be halfway between that element and the next categories[i] = 0.5 * (values[indexOfLast] + values[indexOfLast+1]); // Decrement count of correct bucket type. if (doingSmallBucket) nearlyFullBuckets--; else fullBuckets--; } for (int kk = 0; kk < numCats+1; kk++) { distValues.push_back(categories[kk]); } delete[] categories; // Delete the memory allocated before }
// Calculate Standard Deviation for the values void MgFeatureNumericFunctions::GetStandardDeviationCategories( VECTOR &values, int numCats, double dataMin, double dataMax, VECTOR &distValues) { // Expected categories should be more than zero if (numCats <= 0) { STRING message = MgServerFeatureUtil::GetMessage(L"MgInvalidComputedProperty"); MgStringCollection arguments; arguments.Add(message); throw new MgFeatureServiceException(L"MgServerSelectFeatures.GetEqualCategories", __LINE__, __WFILE__, &arguments, L"", NULL); } // collect information about the data values double min = DoubleMaxValue; double max = -DoubleMaxValue; double mean = 0; int cnt = (int)values.size(); if (cnt <= 0) { return; } // Nothing to do, we just send back Property Definition to clients from reader for (int i=0; i < cnt; i++) { double val = values[i]; if (val > max) max = val; if (val < min) min = val; mean += val; } // expand min and max a little to account for numerical instability double delta = 0.0001 * (max - min); min -= delta; max += delta; // compute the mean, variance and standard deviation double count = (double)cnt; // (guaranteed to be > 0) mean /= count; double variance = 0; for (int i=0; i < cnt; i++) { double val = values[i]; variance += (val - mean) * (val - mean); } double deviation = sqrt(variance / count); // fill in the middle category/categories double* cats = new double[numCats+1]; int midCat, highMidCat; if (numCats % 2 == 0) { midCat = numCats / 2; highMidCat = midCat; cats[midCat] = mean; } else { midCat = (numCats - 1) / 2; highMidCat = midCat + 1; cats[midCat] = mean - 0.5 * deviation; cats[highMidCat] = mean + 0.5 * deviation; } // fill in the other categories for (int i=midCat-1; i>=0; i--) cats[i] = cats[i+1] - deviation; for (int i=highMidCat; i<=numCats; i++) cats[i] = cats[i-1] + deviation; // if the data method specifies strict a strict min and/or max, use them if (!IsInf(dataMin) && !IsNan(dataMin) && (dataMin != -DoubleMaxValue)) min = dataMin; if (!IsInf(dataMax) && !IsNan(dataMax) && (dataMax != DoubleMaxValue)) max = dataMax; // flatten/clip any categories that extend beyond the min/max range for (int i=0; i<=numCats; i++) { if (cats[i] < min) cats[i] = min; else if (cats[i] > max) cats[i] = max; } for (int kk = 0; kk < numCats+1; kk++) { distValues.push_back(cats[kk]); } delete[] cats; // Delete the memory allocated before }
Grnn::Trainer::Trainer(const MATRIX& X, const VECTOR& y) : X_(&X), y_(&y), z_(VECTOR(y.size(), 0.0)) { setDefaultParameters(); }