void netcdf_write_blitz(NcVar *nc_var, blitz::Array<T, rank> const &val) { long counts[rank]; for (int i=0; i<rank; ++i) counts[i] = val.extent(i); //printf("netcdf_write_blitz: %p %p\n", nc_var, val.data()); nc_var->put(val.data(), counts); }
void GridDomain::global_to_local( blitz::Array<double,1> const &global, std::vector<blitz::Array<double,1>> &olocal) { if (olocal.size() != this->num_local_indices) { fprintf(stderr, "MatrixDomainer::get_rows() had bad dimension 1 = %d (expected %ld)\n", olocal.extent(1), this->num_local_indices); throw std::exception(); } for (auto ii = olocal.begin(); ii != olocal.end(); ++ii) { // Make sure it has the right dimensions if (olocal[i].extent(0) != global.extent(0)) { fprintf(stderr, "MatrixDomainer::get_rows() had bad dimension 0 = %d (expected %ld)\n", olocal.extent(0), global.extent(0)); throw std::exception(); } } // Copy out data, translating to local coordinates for (int j=0; j < global.extent(0); ++j) { int lindex[this->num_local_indices]; this->global_to_local(global(j), lindex); for (int i=0; i<this->num_local_indices; ++i) olocal[i](j) = lindex[i]; } }
void GmresWrapper<Rank>::ApplyOperator(blitz::Array<cplx, 1> &input, blitz::Array<cplx, 1> &output) { if (Psi == 0) { throw std::runtime_error("Psi is 0"); } if (TempPsi == 0) { throw std::runtime_error("TempPsi is 0"); } //Map the 1d vectors to a a blitz array of correct shape DataVector shape = Psi->GetData().shape(); DataVector stride = Psi->GetData().stride(); DataArray inData(input.data(), shape, stride, blitz::neverDeleteData); DataArray inData2(input.data(), shape, stride, blitz::neverDeleteData); DataArray outData(output.data(), shape, stride, blitz::neverDeleteData); DataArray outData2(output.data(), shape, stride, blitz::neverDeleteData); outData = 0; //Set psi and tempPsi to point to correct vectorsbuffers DataArray oldData = Psi->GetData(); DataArray oldTempData = TempPsi->GetData(); Psi->SetData(inData); TempPsi->SetData(outData); OperatorCallback(Psi, TempPsi); //Restore the former buffers Psi->SetData(oldData); TempPsi->SetData(oldTempData); }
void mouse( int button, int state, int x, int y) { //#define CLICK_SAVE_COLS #ifdef CLICK_SAVE_COLS int kw = 16; int xmin, xmax, ymin, ymax; xmin = std::max( 1, x - kw); ymin = std::max( 1, y - kw); xmax = std::min( x + kw, image.cols() - 1); ymax = std::min( y + kw, image.rows() - 1); std::ofstream of( "cluster_dat.hpp"); if( !of) return; of << "const int num_pts = " << (xmax - xmin) * (ymax - ymin) * 4 << ";\n"; of << "float dat[num_pts] = {\n"; for( int j=ymin;j<ymax;++j) { for( int i=xmin;i<xmax;++i) { Imath::Color3f col = image( j, i); of << col.x << ", " << col.y << ", " << col.z << ", 1.0, \n"; } } of << "};\n"; #endif }
double bob::learn::em::GMMMachine::logLikelihood(const blitz::Array<double, 1> &x, blitz::Array<double,1> &log_weighted_gaussian_likelihoods) const { // Check dimension bob::core::array::assertSameDimensionLength(log_weighted_gaussian_likelihoods.extent(0), m_n_gaussians); bob::core::array::assertSameDimensionLength(x.extent(0), m_n_inputs); return logLikelihood_(x,log_weighted_gaussian_likelihoods); }
inline double Inverse_Matrix_with_lapack_and_Return_Determinant (blitz::Array<double,2> & M, std::string message="") { assert (M.rows() ==M.cols()); int n = M.rows(); if (n==0) return 1; ref<double,2> refM(M,false);//do not check the ordering since inverse and transposition commutes double * p = refM; return Inverse_Matrix_with_lapack_and_Return_Determinant(p,n,n,message); }
void IceModel_Decode::run_timestep(double time_s, blitz::Array<int,1> const &indices, std::map<IceField, blitz::Array<double,1>> const &vals2) { printf("BEGIN IceModel_Decode::run_timestep(%f) size=%ld\n", time_s, indices.size()); std::map<IceField, blitz::Array<double,1>> vals2d; /// Decoded fields // Loop through the fields we require std::set<IceField> fields; get_required_fields(fields); for (auto field = fields.begin(); field != fields.end(); ++field) { printf("Looking for required field %s\n", field->str()); // Look up the field we require auto ii = vals2.find(*field); if (ii == vals2.end()) { fprintf(stderr, "Cannot find required ice field = %s\n", field->str()); throw std::exception(); } blitz::Array<double,1> vals(ii->second); // Decode the field! blitz::Array<double,1> valsd(ndata()); valsd = nan; int n = indices.size(); for (int i=0; i < n; ++i) { int ix = indices(i); // Do our own bounds checking! if (ix < 0 || ix >= ndata()) { fprintf(stderr, "IceModel: index %d out of range [0, %d)\n", ix, ndata()); throw std::exception(); } #if 0 // Sanity check for NaN coming through if (std::isnan(vals(i))) { fprintf(stderr, "IceModel::decode: vals[%d] (index=%d) is NaN!\n", i, ix); throw std::exception(); } #endif // Add this value to existing field double &oval = valsd(ix); if (std::isnan(oval)) oval = vals(i); else oval += vals(i); } // Store decoded field in our output vals2d.insert(std::make_pair(*field, valsd)); printf("Done decoding required field, %s\n", field->str()); } // Pass decoded fields on to subclass run_decoded(time_s, vals2d); printf("END IceModel_Decode::run_timestep(%ld)\n", time_s); }
blitz::Array<double,1> bob::example::library::reverse (const blitz::Array<double,1>& array){ // create new array in the desired shape blitz::Array<double,1> retval(array.shape()); // copy data for (int i = 0, j = array.extent(0)-1; i < array.extent(0); ++i, --j){ retval(j) = array(i); } // return the copied data return retval; }
void Machine::setInputDivision (const blitz::Array<double,1>& v) { if (m_weight.extent(0) != v.extent(0)) { boost::format m("mismatch on the input division shape: expected a vector of size %d, but you input one with size = %d instead"); m % m_weight.extent(0) % v.extent(0); throw std::runtime_error(m.str()); } m_input_div.reference(bob::core::array::ccopy(v)); }
void Machine::setBiases (const blitz::Array<double,1>& bias) { if (m_weight.extent(1) != bias.extent(0)) { boost::format m("mismatch on the bias shape: expected a vector of size %d, but you input one with size = %d instead"); m % m_weight.extent(1) % bias.extent(0); throw std::runtime_error(m.str()); } m_bias.reference(bob::core::array::ccopy(bias)); }
Mat naiveBlitzToCvMat(blitz::Array<float, 2> a, float multiplier){ int i, j; Mat b = Mat(a.rows(), a.cols(), CV_32FC1); for (i=0; i< a.rows(); i++){ for(j=0; j<a.cols(); j++){ b.at<float>(i,j) = a(i, j) * multiplier; } } return b; }
void binary_save(const blitz::Array<T,n> & M,std::string filename) { T z;assert(M.isStorageContiguous()); std::stringstream f;M.dumpStructureInformation(f); std::ofstream out(filename.c_str(),std::ios::binary); std::string s = f.str();int i=int(s.length())+1;char c='1'; out.write( (char*) &i,sizeof(i)); out.write( (s.c_str()) ,i*sizeof(c)); out.write( (char*)M.dataFirst(),M.numElements()*sizeof(z)); }
void convert2rgb( blitz::Array<Imath::Color3f,2>& img) { vigra::BasicImageView<vigra::TinyVector<float,3> > img_view( (vigra::TinyVector<float,3> *) img.dataFirst(), img.cols(), img.rows()); for( int j=0;j<img.rows();++j) for( int i=0;i<img.cols();++i) img( j, i) *= lab_scale; vigra::transformImage( vigra::srcImageRange( img_view), vigra::destImage( img_view), vigra::Lab2RGBFunctor<float>( 1.0f)); }
inline void for_cons(const blitz::Array<T,n> & M, bool check_order){ need_copy = (!(M.isStorageContiguous())); if (check_order) for (int i=0; i<n;i++) need_copy = (need_copy || (M.ordering(i)!=i)); #ifdef DEBUG_REF_WARNING if (need_copy) std::cout<<"WARNING : REF : COPY NEEDED. Performance will be degraded"<<std::endl; #endif Mref = (blitz::Array<T,n> *)&M; // The copy has the same shape but is ordered like a fortran array if (need_copy) {Mcopy.resize(M.shape());Mcopy=M;} }
void binary_load(blitz::Array<T,n> & M,std::string filename) { assert(M.isStorageContiguous());T z; std::ifstream out(filename.c_str(),std::ios::binary); int i;char c='1'; out.read( (char*) &i,sizeof(i)); char *st = new char[i+1]; out.read( st ,i*sizeof(c)); std::string s(st); std::stringstream f; M.dumpStructureInformation(f); if (f.str() != s) FATAL("Can not load binary : array do not conform. Structure (file vs array)"<<s<<"----"<<f.str()); out.read( (char*)M.dataFirst(),M.numElements()*sizeof(z)); }
Machine::Machine(const blitz::Array<double,2>& weight) : m_input_sub(weight.extent(0)), m_input_div(weight.extent(0)), m_bias(weight.extent(1)), m_activation(boost::make_shared<bob::learn::activation::IdentityActivation>()), m_buffer(weight.extent(0)) { m_input_sub = 0.0; m_input_div = 1.0; m_bias = 0.0; m_weight.reference(bob::core::array::ccopy(weight)); }
double bob::learn::em::GMMMachine::logLikelihood(const blitz::Array<double, 2> &x) const { // Check dimension bob::core::array::assertSameDimensionLength(x.extent(1), m_n_inputs); // Call the other logLikelihood_ (overloaded) function double sum_ll = 0; for (int i=0; i<x.extent(0); i++) sum_ll+= logLikelihood_(x(i,blitz::Range::all())); return sum_ll/x.extent(0); }
void check_dimensions( std::string const &vname, blitz::Array<T, rank> const &arr, std::vector<int> const &dims) { for (int i=0; i<rank; ++i) { if (dims[i] >= 0 && arr.extent(i) != dims[i]) { fprintf(stderr, "Error in %s: expected dimension #%d = %d (is %d instead)\n", vname.c_str(), i, dims[i], arr.extent(i)); throw std::exception(); } } }
void Machine::forward (const blitz::Array<double,1>& input, blitz::Array<double,1>& output) const { if (m_weight.extent(0) != input.extent(0)) { //checks input dimension boost::format m("mismatch on the input dimension: expected a vector of size %d, but you input one with size = %d instead"); m % m_weight.extent(0) % input.extent(0); throw std::runtime_error(m.str()); } if (m_weight.extent(1) != output.extent(0)) { //checks output dimension boost::format m("mismatch on the output dimension: expected a vector of size %d, but you input one with size = %d instead"); m % m_weight.extent(1) % output.extent(0); throw std::runtime_error(m.str()); } forward_(input, output); }
void Machine::setWeights (const blitz::Array<double,2>& weight) { if (weight.extent(0) != m_input_sub.extent(0)) { //checks 1st dimension boost::format m("mismatch on the weight shape (number of rows): expected a weight matrix with %d row(s), but you input one with %d row(s) instead"); m % m_input_sub.extent(0) % weight.extent(0); throw std::runtime_error(m.str()); } if (weight.extent(1) != m_bias.extent(0)) { //checks 2nd dimension boost::format m("mismatch on the weight shape (number of columns): expected a weight matrix with %d column(s), but you input one with %d column(s) instead"); m % m_bias.extent(0) % weight.extent(1); throw std::runtime_error(m.str()); } m_weight.reference(bob::core::array::ccopy(weight)); }
double bob::math::det_(const blitz::Array<double,2>& A) { // Size variable int N = A.extent(0); // Perform an LU decomposition blitz::Array<double,2> L(N,N); blitz::Array<double,2> U(N,N); blitz::Array<double,2> P(N,N); math::lu(A, L, U, P); // Compute the determinant of A = det(P*L)*PI(diag(U)) // where det(P*L) = +- 1 (Number of permutation in P) // and PI(diag(U)) is the product of the diagonal elements of U blitz::Array<double,2> Lperm(N,N); math::prod(P,L,Lperm); int s = 1; double Udiag=1.; for (int i=0; i<N; ++i) { for (int j=i+1; j<N; ++j) if (P(i,j) > 0) { s = -s; break; } Udiag *= U(i,i); } return s*Udiag; }
double bob::learn::em::GMMMachine::logLikelihood(const blitz::Array<double, 1> &x) const { // Check dimension bob::core::array::assertSameDimensionLength(x.extent(0), m_n_inputs); // Call the other logLikelihood_ (overloaded) function // (log_weighted_gaussian_likelihoods will be discarded) return logLikelihood_(x,m_cache_log_weighted_gaussian_likelihoods); }
void bob::learn::em::GMMMachine::setVarianceThresholds(const blitz::Array<double, 2>& variance_thresholds) { bob::core::array::assertSameDimensionLength(variance_thresholds.extent(0), m_n_gaussians); bob::core::array::assertSameDimensionLength(variance_thresholds.extent(1), m_n_inputs); for(size_t i=0; i<m_n_gaussians; ++i) m_gaussians[i]->setVarianceThresholds(variance_thresholds(i,blitz::Range::all())); m_cache_supervector = false; }
double bob::math::slogdet_(const blitz::Array<double,2>& A, int& sign) { // Size variable int N = A.extent(0); // Perform an LU decomposition blitz::Array<double,2> L(N,N); blitz::Array<double,2> U(N,N); blitz::Array<double,2> P(N,N); math::lu(A, L, U, P); // Compute the determinant of A = det(P*L)*SI(diag(U)) // where det(P*L) = +- 1 (Number of permutation in P) // and SI(diag(log|U|)) is the sum of the logarithm of the // diagonal elements of U blitz::Array<double,2> Lperm(N,N); math::prod(P,L,Lperm); sign = 1; double Udiag=0.; for (int i=0; i<N; ++i) { for (int j=i+1; j<N; ++j) if (P(i,j) > 0) { sign = -sign; break; } Udiag += log(fabs(U(i,i))); } // Check for infinity if ((Udiag*-1) == std::numeric_limits<double>::infinity()) sign = 0; return Udiag; }
void bob::learn::em::GMMMachine::setMeans(const blitz::Array<double,2> &means) { bob::core::array::assertSameDimensionLength(means.extent(0), m_n_gaussians); bob::core::array::assertSameDimensionLength(means.extent(1), m_n_inputs); for(size_t i=0; i<m_n_gaussians; ++i) m_gaussians[i]->updateMean() = means(i,blitz::Range::all()); m_cache_supervector = false; }
void bob::learn::boosting::LUTTrainer::weightedHistogram(const blitz::Array<uint16_t,1>& features, const blitz::Array<double,1>& weights) const{ bob::core::array::assertSameShape(features, weights); _gradientHistogram = 0.; for (int i = features.extent(0); i--;){ _gradientHistogram((int)features(i)) += weights(i); } }
void bob::learn::em::GMMMachine::setVarianceSupervector(const blitz::Array<double,1> &variance_supervector) { bob::core::array::assertSameDimensionLength(variance_supervector.extent(0), m_n_gaussians*m_n_inputs); for(size_t i=0; i<m_n_gaussians; ++i) { m_gaussians[i]->updateVariance() = variance_supervector(blitz::Range(i*m_n_inputs, (i+1)*m_n_inputs-1)); m_gaussians[i]->applyVarianceThresholds(); } m_cache_supervector = false; }
void gl_init( void) { glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 ); glClearColor ( 0.0F, 0.0F, 0.0F, 0.0F ); glViewport ( 0, 0, image.cols(), image.rows()); // set coordinate frame for graphics in window glMatrixMode ( GL_PROJECTION ); glLoadIdentity(); gluOrtho2D ( 0, image.cols(), image.rows(), 0); glMatrixMode ( GL_MODELVIEW); glLoadIdentity(); glPixelZoom( 1, -1); }
void bob::learn::em::GMMMachine::accStatistics_(const blitz::Array<double,2>& input, bob::learn::em::GMMStats& stats) const { // iterate over data blitz::Range a = blitz::Range::all(); for(int i=0; i<input.extent(0); ++i) { // Get example blitz::Array<double,1> x(input(i, a)); // Accumulate statistics accStatistics_(x,stats); } }
int32_t bob::learn::boosting::LUTTrainer::bestIndex(const blitz::Array<double,1>& array) const{ double min = std::numeric_limits<double>::max(); int32_t minIndex = -1; for (int i = 0; i < array.extent(0); ++i){ if (array(i) < min){ min = array(i); minIndex = i; } } return minIndex; }