/* interpolate a quarter (half a window) * * ibuf buffer of ilen length is swept at rate speed. * result put in output buffer obuf of size olen. */ static void interpolation( pitch_t pitch, st_sample_t *ibuf, int ilen, PITCH_FLOAT * out, int olen, PITCH_FLOAT rate) /* signed */ { register int i, size; register PITCH_FLOAT index; size = pitch->step; /* size == olen? */ if (rate>0) /* sweep forwards */ { for (index=ZERO, i=0; i<olen; i++, index+=rate) { register int ifl = (int) index; /* FLOOR */ register PITCH_FLOAT frac = index - ifl; if (pitch->interopt==PITCH_INTERPOLE_LIN) out[i] = lin((PITCH_FLOAT) ibuf[ifl], (PITCH_FLOAT) ibuf[ifl+1], frac); else out[i] = cub((PITCH_FLOAT) ibuf[ifl-1], (PITCH_FLOAT) ibuf[ifl], (PITCH_FLOAT) ibuf[ifl+1], (PITCH_FLOAT) ibuf[ifl+2], frac); } } else /* rate < 0, sweep backwards */ { for (index=ilen-1, i=olen-1; i>=0; i--, index+=rate) { register int ifl = (int) index; /* FLOOR */ register PITCH_FLOAT frac = index - ifl; if (pitch->interopt==PITCH_INTERPOLE_LIN) out[i] = lin((PITCH_FLOAT) ibuf[ifl], (PITCH_FLOAT) ibuf[ifl+1], frac); else out[i] = cub((PITCH_FLOAT) ibuf[ifl-1], (PITCH_FLOAT) ibuf[ifl], (PITCH_FLOAT) ibuf[ifl+1], (PITCH_FLOAT) ibuf[ifl+2], frac); } } }
bool compare_files(std::string layout_file, std::string schematic_file) { std::ifstream sin(schematic_file.c_str()); std::ifstream lin(layout_file.c_str()); std::vector<layout_rectangle> rects; std::vector<layout_pin> pins; parse_layout(rects, pins, lin); schematic_database reference_schematic; parse_schematic_database(reference_schematic, sin); layout_database layout; populate_layout_database(layout, rects); connectivity_database connectivity; populate_connectivity_database(connectivity, pins, layout); schematic_database schematic; std::vector<device>& devices = schematic.devices; for(std::size_t i = 0; i < pins.size(); ++i) { devices.push_back(device()); devices.back().type = "PIN"; devices.back().terminals.push_back(pins[i].net); } extract_devices(devices, connectivity, layout); extract_netlist(schematic.nets, devices); return compare_schematics(reference_schematic, schematic); }
rndf::PerimeterPoint* REPerimeterPoint::create(rndf::Perimeter* p, double utm_x, double utm_y, const string& utm_zone) { if (!p) {return NULL;} unsigned int index; if (elem_) { if (elem_->perimeter() == p) { if (elem_->index() < p->numPerimeterPoints() - 1) { rndf::PerimeterPoint* p1 = p->perimeterPoint(elem_->index()); rndf::PerimeterPoint* p2 = p->perimeterPoint(elem_->index() + 1); Line_2 lin(Point_2(p1->utmX(), p1->utmY()), Point_2(p2->utmX(), p2->utmY())); Point_2 p = lin.projection(Point_2(utm_x, utm_y)); utm_x = p.x(); utm_y = p.y(); } } index = elem_->index() + 1; } else { index = p->numPerimeterPoints(); } double lat, lon; utmToLatLong(utm_x, utm_y, utm_zone, &lat, &lon); elem_ = rn_->addPerimeterPoint(p, lat, lon, index); return elem_; }
int main(){ int n,choose; while(1){ scanf("%d %d",&choose,&n); switch(choose){ case 0:return; case 1: lin(n); break; case 2: even(n+1); break; case 3: odd(n); break; default: printf("error"); } } return; }
History & History::get (Vector<float> & past) { ASSERT_SIZE(past, size_out()); past.zero(); m_spline_weights.zero(); for (Frame * f = m_frames; f; f = f->next) { float i = log_time(f->time); LinearInterpolate lin(i, m_length); m_spline_weights[lin.i0] += lin.w0; m_spline_weights[lin.i1] += lin.w1; float scale = 1.0 / f->num_terms(); Vector<float> past0 = past.block(m_size, lin.i0); Vector<float> past1 = past.block(m_size, lin.i1); if (lin.w0 > 0) multiply_add(lin.w0 * scale, f->data, past0); if (lin.w1 > 0) multiply_add(lin.w1 * scale, f->data, past1); } for (size_t i = 0; i < m_length; ++i) { Vector<float> past_i = past.block(m_size, i); if (m_spline_weights[i] > 0) { float normalize_factor = 1.0 / m_spline_weights[i]; LOG1("normalize_factor = " << normalize_factor); for (size_t j = 0; j < m_size; ++j) { past_i[j] *= normalize_factor; } } } return * this; }
void FGFDMExec::DoLinearization(int mode) { double saved_time; if (Constructing) return; saved_time = sim_time; FGLinearization lin(this,mode); Setsim_time(saved_time); }
void tet_basis::proj2d_bdry(FLT *lin1, FLT *f1, int stride) { Array<FLT,2> wk0(gpy,3+em); const int be2 = em+3, be3 = 2*em+3; const int lgpx = gpx, lgpy = gpy, lnmodx = nmodx; int sign; FLT lcl0; #ifdef BZ_DEBUG Array<FLT,1> lin(lin1, shape(3+3*em+fm), neverDeleteData); Array<FLT,2> f(f1, shape(gpx,stride), neverDeleteData); #endif /* DETERMINE U VALUES, GRAD U VALUES AT COLLOCATION POINTS SUM HAT(U) FOR DU/DX AND DU/DY */ /* PART I - sum u*g_mn for each n, s_j */ for(int j = 0; j < lgpy; ++j ) { /* VERTEX 1 */ wk0(j,0) = lin(0)*gy(j,1); /* VERTEX 2, EDGE 3 */ sign = 1; lcl0 = lin(1)*gy(j,2); for(int i = 0; i < em; ++i){ lcl0 += sign*lin(be3+i)*gy(j,3+em+i); sign*=-1; } wk0(j,1) = lcl0; /* VERTEX 3, EDGE 2 */ lcl0 = lin(2)*gy(j,2); for(int i = 0; i < em; ++i){ lcl0 += lin(be2+i)*gy(j,3+em+i); } wk0(j,2) = lcl0; /* EDGE 1 */ for(int p = 3; p < em+3; ++p){ wk0(j,p)=lin(p)*gy(j,p); } } /* SUM OVER N AT EACH I,J POINT */ for (int i = 0; i < lgpx; ++i ) { for (int j = 0; j < lgpy; ++j) { lcl0 = wk0(j,0)*gx(i,0); for(int n = 1; n < lnmodx; ++n ) { lcl0 += wk0(j,n)*gx(i,n); } f(i,j) = lcl0; } } return; }
void tet_basis::proj2d_bdry_leg(FLT *lin1, FLT *f1, int stride) { const int ltm = 3+3*em; FLT lcl0; #ifdef BZ_DEBUG Array<FLT,1> lin(lin1, shape(3+3*em+fm), neverDeleteData); Array<FLT,2> f(f1, shape(gpx,stride), neverDeleteData); #endif /* INTERIOR */ for(int i = 1; i < em; ++i) { for(int j = 1; j < em+1-i; ++j) { lcl0 = 0.0; for(int m = 0; m < ltm; ++m) lcl0 += lin(m)*lgrnge2d(m,i,j); f(i,j) = lcl0; } } return; }
Real value( const ROL::Vector<Real> &x, Real &tol ) { Teuchos::RCP<const std::vector<Real> > ex = Teuchos::dyn_cast<const ROL::StdVector<Real> >(x).getVector(); Real quad(0), lin(0); std::vector<Real> p = ROL::ParametrizedObjective<Real>::getParameter(); unsigned size = static_cast<unsigned>(ex->size()); for ( unsigned i = 0; i < size; i++ ) { quad += (*ex)[i]*(*ex)[i]; lin += (*ex)[i]*p[i+1]; } return std::exp(p[0])*quad + lin + p[size+1]; }
Vector3D CPolyDlg::GetCnrVector( CString cnrstr ) { //Extract 3D coordinates from vertex string. String is assumed to be: // "[cnrnum] [v.x] [v.y] [v.z] R G B" istrstream lin( cnrstr.GetBuffer( cnrstr.GetLength() ) ) ; //extract & discard corner number if necessary if( GetNumTokens( cnrstr ) > 6 ) { int cnrnum ; lin >> cnrnum ; }
void clean_space(char *str) { int i; int y; y = -1; while (str[++y]) if (str[y] == SEPARATOR_CHAR) { i = y; while (--i >= 0 && (str[i] == ' ' || str[i] == ' ' || str[i] == SEPARATOR_CHAR)) if (str[i] == SEPARATOR_CHAR) error_exit(ft_strjoin("Syntax Error, Bad separator on line:" , ft_itoa(lin(1))), EINVAL); else str[i] = SEPARATOR_CHAR; clean_space2(str, &y); if (!str[i]) error_exit(ft_strjoin("Syntax Error, Bad separator on line:" , ft_itoa(lin(1))), EINVAL); } }
static void clean_space2(char *str, int *y) { int i; i = *y; while (str[++i] && (str[i] == ' ' || str[i] == ' ' || str[i] == SEPARATOR_CHAR)) if (str[i] == SEPARATOR_CHAR) error_exit(ft_strjoin("Syntax Error, Bad separator on line:" , ft_itoa(lin(1))), EINVAL); else str[i] = SEPARATOR_CHAR; *y = i; }
void test_panning_sin() { Sine vox(330); MulOp mul(vox, 0.2); LineSegment lin(6, -1, 1); // L-to-R sweep over 6 sec Panner pan(mul, lin); logMsg("playing panning sin 1..."); run_test(pan, 6.0); logMsg("panning sin done."); Sine pos(0.5); // LFO panning Panner pan2(mul, pos); logMsg("playing panning sin 2..."); run_test(pan2, 5.0); logMsg("panning sin done."); }
void TempoFlockViewer::plot_beat () { const size_t I = synth().size(); const size_t X = Rectangle::width(); const size_t Y = Rectangle::height(); const float * restrict mass = synth().get_mass(); const float * restrict phase_x = synth().get_phase_x(); const float * restrict phase_y = synth().get_phase_y(); const complex r_part = exp_2_pi_i(0 / 3.0f); const complex g_part = exp_2_pi_i(1 / 3.0f); const complex b_part = exp_2_pi_i(2 / 3.0f); float * restrict red = m_image.red; float * restrict green = m_image.green; float * restrict blue = m_image.blue; //const float * restrict acuity = synth().get_acuity(); //const float acuity1 = synth().max_acuity(); const float * restrict duration = synth().get_duration(); const float duration0 = synth().min_duration(); if (m_image_mutex.try_lock()) { if (m_rhythm_mutex.try_lock()) { for (size_t i = 0; i < I; ++i) { complex phase(phase_x[i], phase_y[i]); float x = wrap(arg(phase) / (2 * M_PI) + 0.5f); //float y = synth().acuity_cdf(acuity[i], acuity1); float y = synth().duration_cdf(duration[i], duration0); float m = min(mass[i], 1.0f); float r = m; float g = sqr(m); float b = 1; BilinearInterpolate lin(x * X, X, y * Y, Y); lin.imax(red, r); lin.imax(green, g); lin.imax(blue, b); } m_rhythm_mutex.unlock(); } m_image_mutex.unlock(); } }
SpatialAcc Axis::getRotationSpatialAcc(const double d2theta) const { SpatialAcc ret; Eigen::Map<Eigen::Vector3d> lin(ret.getLinearVec3().data()); Eigen::Map<Eigen::Vector3d> ang(ret.getAngularVec3().data()); Eigen::Map<const Eigen::Vector3d> dir(direction.data()); Eigen::Map<const Eigen::Vector3d> orig(origin.data()); lin = d2theta*(orig.cross(dir)); ang = dir*d2theta; return ret; }
int main() { // for a simple second test // let's just output in a csv our kernels over 2D surfaces CovMat<2> eye; eye << 1, 0, 0, 1; FeatVec<2> mean; mean << 2, 2; const std::vector<double> std_params = {1.0, 1.0, 1.0}; const std::vector<double> lin_params = {-2.0, 1.0, 1.0}; KernExpression<2> se(se_generator<2>(std_params), mean, eye); KernExpression<2> per(per_generator<2>(std_params), mean, eye); KernExpression<2> lin(lin_generator<2>(lin_params), mean, eye); KernExpression<2> rq(rq_generator<2>(std_params), mean, eye); auto& se_x_per = se * per; auto& se_x_lin = se * lin; auto& per_x_lin = per * lin; auto& per_p_lin = per + lin; auto& se_p_per = se + per; std::ofstream se_dump("../../data-plots/se.csv"); std::ofstream per_dump("../../data-plots/per.csv"); std::ofstream lin_dump("../../data-plots/lin.csv"); std::ofstream rq_dump("../../data-plots/rq.csv"); std::ofstream se_x_per_dump("../../data-plots/se_x_per.csv"); std::ofstream se_x_lin_dump("../../data-plots/se_x_lin.csv"); std::ofstream per_x_lin_dump("../../data-plots/per_x_lin.csv"); std::ofstream per_p_lin_dump("../../data-plots/per_p_lin.csv"); std::ofstream se_p_per_dump("../../data-plots/se_p_per.csv"); test_2d_expression(se, se_dump, 100, 4); test_2d_expression(per, per_dump, 100, 4); test_2d_expression(lin, lin_dump, 100, 4); test_2d_expression(rq, rq_dump, 100, 4); test_2d_expression(se_x_per, se_x_per_dump, 100, 4); test_2d_expression(se_x_lin, se_x_lin_dump, 100, 4); test_2d_expression(se_p_per, se_p_per_dump, 100, 4); test_2d_expression(per_x_lin, per_x_lin_dump, 100, 4); test_2d_expression(per_p_lin, per_p_lin_dump, 100, 4); return 0; }
int main() { size_t sizeRows = 0; size_t sizeColumns = 0; std::vector<float> inputMatrix; std::vector<float> inputVector; std::vector<float> answer; readLinearEquations(inputMatrix, inputVector, sizeRows, sizeColumns); Matrix a(inputMatrix, sizeRows, sizeColumns); LinearVector b(inputVector); SystemLinearEquations lin(a, b); lin.JacodMethod(); answer = lin.getAnswer(); printAnswer(answer); }
static GEN gen_Z2x_Dixon(GEN F, GEN V, long N, void *E, GEN lin(void *E, GEN F, GEN d, long N), GEN invl(void *E, GEN d)) { pari_sp av = avma; long N2, M; GEN VN2, V2, VM, bil; ulong q = 1UL<<N; if (N == 1) return invl(E, V); V = Flx_red(V, q); N2 = (N + 1)>>1; M = N - N2; F = FlxT_red(F, q); VN2 = gen_Z2x_Dixon(F, V, N2, E, lin, invl); bil = lin(E, F, VN2, N); V2 = Z2x_rshift(Flx_sub(V, bil, q), N2); VM = gen_Z2x_Dixon(F, V2, M, E, lin, invl); return gerepileupto(av, Flx_add(VN2, Flx_Fl_mul(VM, 1UL<<N2, q), q)); }
int main() { Segment_2 seg(Point_2(0,0), Point_2(1,1)); Line_2 lin(1,-1,0); // with C++11 support // auto result = intersection(seg, lin); // without C++11 CGAL::cpp11::result_of<Intersect_2(Segment_2, Line_2)>::type result = intersection(seg, lin); if (result) { boost::apply_visitor(Intersection_visitor(), *result); } else { // no intersection } return 0; }
void PitchFlockViewer::plot_bend () { const size_t I = synth().size; const size_t X = Rectangle::width(); const size_t Y = Rectangle::height(); const float * restrict power = get_power(); const float * restrict energy = get_energy(); const float * restrict bend = synth().get_bend(); float * restrict red = m_bend_image.red; float * restrict green = m_bend_image.green; float * restrict blue = m_bend_image.blue; float energy_gain = m_energy_gain.update(max(get_energy())); float power_gain = m_power_gain.update(max(get_power())); float bend_variance = norm_squared(synth().get_bend()) / I; float bend_gain = m_bend_gain.update(bend_variance); float min_freq = min(synth().get_freq()); float max_freq = max(synth().get_freq()); float pitch_scale = 1 / log(max_freq / min_freq); if (m_image_mutex.try_lock()) { for (size_t i = 0; i < I; ++i) { float m = energy_gain * energy[i]; float e = power_gain * power[i]; float b = atanf(0.5f * bend_gain * bend[i]) / M_PI + 0.5f; float p = static_cast<float>(i) / I + pitch_scale * log(1 + bend[i]); BilinearInterpolate lin(b * X, X, p * Y, Y); lin.imax(red, e); lin.imax(green, m); lin.imax(blue, 1); } m_image_mutex.unlock(); } }
static GEN gen_Z2X_Dixon(GEN F, GEN V, long N, void *E, GEN lin(void *E, GEN F, GEN d, long N), GEN lins(void *E, GEN F, GEN d, long N), GEN invls(void *E, GEN d)) { pari_sp av = avma; long n, m; GEN Xn, Xm, FXn, Vm; if (N<BITS_IN_LONG) { ulong q = 1UL<<N; return Flx_to_ZX(gen_Z2x_Dixon(ZXT_to_FlxT(F,q), ZX_to_Flx(V,q),N,E,lins,invls)); } V = ZX_remi2n(V, N); n = (N + 1)>>1; m = N - n; F = ZXT_remi2n(F, N); Xn = gen_Z2X_Dixon(F, V, n, E, lin, lins, invls); FXn = lin(E, F, Xn, N); Vm = ZX_shifti(ZX_sub(V, FXn), -n); Xm = gen_Z2X_Dixon(F, Vm, m, E, lin, lins, invls); return gerepileupto(av, ZX_remi2n(ZX_add(Xn, ZX_shifti(Xm, n)), N)); }
void PitchFlockViewer::plot_pca_4d () { float timescale = FLOCK_PCA_TIMESCALE_SEC * DEFAULT_AUDIO_FRAMERATE; float dt = 1 / timescale; m_pca.add_sample(synth().get_beat(), dt); const size_t I = synth().size; const size_t X = Rectangle::width(); const size_t Y = Rectangle::height(); float * restrict select_x = m_select_x; float * restrict select_y = m_select_y1; float pca_gain = sqrtf(I) / 8; const float * restrict energy = get_energy(); const float * restrict pca_w = m_pca.component(0); const float * restrict pca_x = m_pca.component(1); const float * restrict pca_y = m_pca.component(2); const float * restrict pca_z = m_pca.component(3); const float * restrict pca_u = m_pca.component(4); const float * restrict pca_v = m_pca.component(5); const float ru = 1.0f; const float bu = cos(2 * M_PI / 3); const float bv = sin(2 * M_PI / 3); const float gu = cos(-2 * M_PI / 3); const float gv = sin(-2 * M_PI / 3); float * restrict energy_image = m_energy_image; float * restrict red = m_pca_image.red; float * restrict green = m_pca_image.green; float * restrict blue = m_pca_image.blue; const LinAlg::Orientation4D angle = m_angle4; if (m_image_mutex.try_lock()) { for (size_t i = 0; i < I; ++i) { float m = energy[i]; float wxyz[4] = {pca_w[i], pca_x[i], pca_y[i], pca_z[i]}; float u = pca_u[i] * pca_gain; float v = pca_v[i] * pca_gain; float uv_scale = 1 / (1 + sqrt(max(1e-20f, sqr(u) + sqr(v)))); u *= uv_scale; v *= uv_scale; float r = sqr((1 + ru * u) / 2); float g = sqr((1 + gu * u + gv * v) / 2); float b = sqr((1 + bu * u + bv * v) / 2); float x = pca_gain * angle.coord_dot(0, wxyz); float y = pca_gain * angle.coord_dot(1, wxyz); float x_01 = select_x[i] = (1 + x) / 2; float y_01 = select_y[i] = (1 + y) / 2; BilinearInterpolate lin(x_01 * X, X, y_01 * Y, Y); lin.imax(energy_image, m); lin.imax(red, r); lin.imax(green, g); lin.imax(blue, b); } m_image_mutex.unlock(); } }
void PitchFlockViewer::plot_pca_freq () { float timescale = FLOCK_PCA_TIMESCALE_SEC * DEFAULT_AUDIO_FRAMERATE; float dt = 1 / timescale; m_pca.add_sample(synth().get_beat(), dt); const size_t I = synth().size; const size_t X = Rectangle::width(); const size_t Y = Rectangle::height(); float * restrict select_x = m_select_x; float * restrict select_y1 = m_select_y1; float * restrict select_y2 = m_select_y2; float pca_gain = sqrtf(I) / 8; float dx_gain = sqrtf(I) / synth().num_tones(); const float * restrict energy = get_energy(); const float * restrict pca_y = m_pca.component(0); const float * restrict pca_z = m_pca.component(1); const float * restrict pca_u = m_pca.component(2); const float * restrict pca_v = m_pca.component(3); const float * restrict pca_dx = m_pca.component(4); const float ru = 1.0f; const float bu = cos(2 * M_PI / 3); const float bv = sin(2 * M_PI / 3); const float gu = cos(-2 * M_PI / 3); const float gv = sin(-2 * M_PI / 3); float * restrict energy_image = m_energy_image; float * restrict red = m_pca_image.red; float * restrict green = m_pca_image.green; float * restrict blue = m_pca_image.blue; const LinAlg::Orientation3D angle = m_angle3; const float skew = 1.0f / 20; if (m_image_mutex.try_lock()) { for (size_t i = 0; i < I; ++i) { float m = energy[i]; float xyz[3] = { 1 - (i + 0.5f) / I * 2 + pca_dx[i] * dx_gain, pca_y[i] * pca_gain, pca_z[i] * pca_gain }; float u = pca_u[i] * pca_gain; float v = pca_v[i] * pca_gain; float uv_scale = 1 / (1 + sqrt(max(1e-20f, sqr(u) + sqr(v)))); u *= uv_scale; v *= uv_scale; float r = sqr((1 + ru * u) / 2); float g = sqr((1 + gu * u + gv * v) / 2); float b = sqr((1 + bu * u + bv * v) / 2); float x = angle.coord_dot(0, xyz); float y = angle.coord_dot(1, xyz); float z = angle.coord_dot(2, xyz); float y1 = y - skew * z; float y2 = y + skew * z; float x_01 = select_x[i] = (1 + x) / 2; float y1_01 = select_y1[i] = (1 + y1) / 4; float y2_01 = select_y2[i] = (1 + y2 + 2) / 4; BilinearInterpolate lin(x_01 * X, X, y1_01 * Y, Y); lin.imax(energy_image, m); lin.imax(red, r); lin.imax(green, g); lin.imax(blue, b); lin.y(y2_01 * Y, Y); lin.imax(energy_image, m); lin.imax(red, r); lin.imax(green, g); lin.imax(blue, b); } m_image_mutex.unlock(); } }
void FlockViewer::plot_pitch () { const size_t I = harmony().size; const size_t X = Rectangle::width(); const size_t Y = Rectangle::height(); const float * restrict selection = m_selection; float pca_gain = sqrtf(I) / 8; const float * restrict pca_x = m_pca.component(0); const float * restrict pca_y = m_pca.component(1); const float * restrict pca_z = m_pca.component(2); const float * restrict pca_u = m_pca.component(3); const float * restrict pca_v = m_pca.component(4); const float ru = 1.0f; const float bu = cos(2 * M_PI / 3); const float bv = sin(2 * M_PI / 3); const float gu = cos(-2 * M_PI / 3); const float gv = sin(-2 * M_PI / 3); float * restrict red = m_image.red; float * restrict green = m_image.green; float * restrict blue = m_image.blue; float * restrict select_x = m_select_x; float * restrict select_y = m_select_y; const LinAlg::Orientation3D angle = m_angle3; if (m_image_mutex.try_lock()) { for (size_t i = 0; i < I; ++i) { float xyz[3] = { pca_x[i] * pca_gain, pca_y[i] * pca_gain, pca_z[i] * pca_gain }; float u = pca_u[i] * pca_gain; float v = pca_v[i] * pca_gain; float uv_scale = 1 / (1 + sqrt(max(1e-20f, sqr(u) + sqr(v)))); u *= uv_scale; v *= uv_scale; float s = selection[i]; float r = max(s, sqr((1 + ru * u) / 2)); float g = max(s, sqr((1 + gu * u + gv * v) / 2)); float b = max(s, sqr((1 + bu * u + bv * v) / 2)); float x = angle.coord_dot(0, xyz); float y = angle.coord_dot(1, xyz); float x_01 = select_x[i] = (1 + x) / 2; float y_01 = select_y[i] = (1 + y) / 2; BilinearInterpolate lin(x_01 * X, X, y_01 * Y, Y); lin.imax(red, r); lin.imax(green, g); lin.imax(blue, b); } m_image_mutex.unlock(); } }
int main() { lin(); par(); return 0; }
/*----------------------------------------------------------------------* | finalize construction of this interface | *----------------------------------------------------------------------*/ bool MOERTEL::Interface::Complete() { if (IsComplete()) { if (OutLevel()>0) std::cout << "MOERTEL: ***WRN*** MOERTEL::Interface::InterfaceComplete:\n" << "MOERTEL: ***WRN*** InterfaceComplete() was called before, do nothing\n" << "MOERTEL: ***WRN*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return true; } //------------------------------------------------------------------- // check for NULL entries in maps bool ok = true; for (int i=0; i<2; ++i) { std::map<int,Teuchos::RCP<MOERTEL::Node> >::const_iterator curr; for (curr=node_[i].begin(); curr!=node_[i].end(); ++curr) { if (curr->second == Teuchos::null) { std::cout << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface # " << Id_ << ":\n" << "***ERR*** found NULL entry in map of nodes\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; ok = false; } } } for (int i=0; i<2; ++i) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; for (curr=seg_[i].begin(); curr!=seg_[i].end(); ++curr) { if (curr->second == Teuchos::null) { std::cout << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface # " << Id_ << ":\n" << "***ERR*** found NULL entry in map of segments\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; ok = false; } } } int lok = ok; int gok = 1; gcomm_.MinAll(&lok,&gok,1); if (!gok) return false; //------------------------------------------------------------------- // check whether all nodes for segments are present // (take in account that node might be on different processor) // this test is expensive and does not scale. It is therefore only performed // when user requests a high output level #if 1 if (OutLevel()>9) { for (int proc=0; proc<gcomm_.NumProc(); ++proc) { for (int side=0; side<2; ++side) { // create length of list of all nodes adjacent to segments on proc int sendsize = 0; if (proc==gcomm_.MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; for (curr=seg_[side].begin(); curr!=seg_[side].end(); ++curr) sendsize += curr->second->Nnode(); } gcomm_.Broadcast(&sendsize,1,proc); // create list of all nodes adjacent to segments on proc std::vector<int> ids(sendsize); if (proc==gcomm_.MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; int counter=0; for (curr=seg_[side].begin(); curr!=seg_[side].end(); ++curr) { const int* segids = curr->second->NodeIds(); for (int i=0; i<curr->second->Nnode(); ++i) ids[counter++] = segids[i]; } } gcomm_.Broadcast(&ids[0],sendsize,proc); // check on all processors for nodes in ids std::vector<int> foundit(sendsize); std::vector<int> gfoundit(sendsize); for (int i=0; i<sendsize; ++i) { foundit[i] = 0; if (node_[side].find(ids[i]) != node_[side].end()) foundit[i] = 1; } gcomm_.MaxAll(&foundit[0],&gfoundit[0],sendsize); for (int i=0; i<sendsize; ++i) { if (gfoundit[i]!=1) { if (gcomm_.MyPID()==proc) std::cout << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** cannot find segment's node # " << ids[i] << "\n" << "***ERR*** in map of all nodes on all procs\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; ids.clear(); foundit.clear(); gfoundit.clear(); gcomm_.Barrier(); return false; } } // tidy up ids.clear(); foundit.clear(); gfoundit.clear(); } // for (int size=0; side<2; ++side) } // for (int proc=0; proc<gcomm_.NumProc(); ++proc) } #endif //------------------------------------------------------------------- // find all procs that have business on this interface (own nodes/segments) // build a Epetra_comm that contains only those procs // this intra-communicator will be used to handle most stuff on this // interface so the interface will not block all other procs { #ifdef EPETRA_MPI std::vector<int> lin(gcomm_.NumProc()); std::vector<int> gin(gcomm_.NumProc()); for (int i=0; i<gcomm_.NumProc(); ++i) lin[i] = 0; // check ownership of any segments for (int i=0; i<2; ++i) if (seg_[i].size() != 0) { lin[gcomm_.MyPID()] = 1; break; } // check ownership of any nodes for (int i=0; i<2; ++i) if (node_[i].size() != 0) { lin[gcomm_.MyPID()] = 1; break; } gcomm_.MaxAll(&lin[0],&gin[0],gcomm_.NumProc()); lin.clear(); // typecast the Epetra_Comm to Epetra_MpiComm Epetra_MpiComm* epetrampicomm = dynamic_cast<Epetra_MpiComm*>(&gcomm_); if (!epetrampicomm) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface " << Id() << ": Epetra_Comm is not an Epetra_MpiComm\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } // split the communicator into participating and none-participating procs int color; int key = gcomm_.MyPID(); // I am taking part in the new comm if I have any ownership if (gin[gcomm_.MyPID()]) color = 0; // I am not taking part in the new comm else color = MPI_UNDEFINED; // tidy up gin.clear(); // create the local communicator MPI_Comm mpi_global_comm = epetrampicomm->GetMpiComm(); MPI_Comm* mpi_local_comm = new MPI_Comm(); MPI_Comm_split(mpi_global_comm,color,key,mpi_local_comm); // create the new Epetra_MpiComm if (*mpi_local_comm == MPI_COMM_NULL) lcomm_ = Teuchos::null; else lcomm_ = Teuchos::rcp(new Epetra_MpiComm(*mpi_local_comm)); // FIXME: who destroys the MPI_Comm inside? #if 0 // test this stuff on the mpi level int grank,lrank; MPI_Comm_rank(mpi_global_comm,&grank); if (*mpi_local_comm != MPI_COMM_NULL) MPI_Comm_rank(*mpi_local_comm,&lrank); else lrank = -1; for (int proc=0; proc<gcomm_.NumProc(); ++proc) { if (proc==gcomm_.MyPID()) std::cout << "using mpi comms: I am global rank " << grank << " and local rank " << lrank << std::endl; gcomm_.Barrier(); } // test this stuff on the epetra level if (lComm()) for (int proc=0; proc<lcomm_->NumProc(); ++proc) { if (proc==lcomm_->MyPID()) std::cout << "using epetra comms: I am global rank " << gcomm_.MyPID() << " and local rank " << lcomm_->MyPID() << std::endl; lcomm_->Barrier(); } gcomm_.Barrier(); #endif #else // the easy serial case Epetra_SerialComm* serialcomm = dynamic_cast<Epetra_SerialComm*>(&gcomm_); if (!serialcomm) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface " << Id() << ": Epetra_Comm is not an Epetra_SerialComm\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } lcomm_ = Teuchos::rcp(new Epetra_SerialComm(*serialcomm)); #endif // end of #ifdef PARALLEL } //------------------------------------------------------------------- // create a map of all nodes to there PID (process id) if (lComm()) for (int proc=0; proc<lcomm_->NumProc(); ++proc) { int lnnodes = 0; if (proc==lcomm_->MyPID()) lnnodes = node_[0].size() + node_[1].size(); lcomm_->Broadcast(&lnnodes,1,proc); std::vector<int> ids(lnnodes); if (proc==lcomm_->MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Node> >::const_iterator curr; int counter=0; for (int side=0; side<2; ++side) for (curr=node_[side].begin(); curr!=node_[side].end(); ++curr) ids[counter++] = curr->first; } lcomm_->Broadcast(&ids[0],lnnodes,proc); for (int i=0; i<lnnodes; ++i) nodePID_.insert(std::pair<int,int>(ids[i],proc)); ids.clear(); } //------------------------------------------------------------------- // create a map of all segments to there PID (process id) if (lComm()) for (int proc=0; proc<lcomm_->NumProc(); ++proc) { int lnsegs = 0; if (proc==lcomm_->MyPID()) lnsegs = seg_[0].size() + seg_[1].size(); lcomm_->Broadcast(&lnsegs,1,proc); std::vector<int> ids(lnsegs); if (proc==lcomm_->MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; int counter=0; for (int side=0; side<2; ++side) for (curr=seg_[side].begin(); curr!=seg_[side].end(); ++curr) ids[counter++] = curr->first; } lcomm_->Broadcast(&ids[0],lnsegs,proc); for (int i=0; i<lnsegs; ++i) segPID_.insert(std::pair<int,int>(ids[i],proc)); ids.clear(); } //------------------------------------------------------------------- // set isComplete_ flag // we set it here already as we will be using some methods that require it // from now on isComplete_ = true; //------------------------------------------------------------------- // make the nodes know there adjacent segments // find max number of nodes to a segment if (lComm()) { int lmaxnnode = 0; int gmaxnnode = 0; for (int side=0; side<2; ++side) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator scurr; for (scurr=seg_[side].begin(); scurr!=seg_[side].end(); ++scurr) if (lmaxnnode < scurr->second->Nnode()) lmaxnnode = scurr->second->Nnode(); } lcomm_->MaxAll(&lmaxnnode,&gmaxnnode,1); // loop all procs and broadcast their adjacency for (int proc=0; proc<lcomm_->NumProc(); ++proc) { // local number of segments int lnseg = 0; if (proc==lcomm_->MyPID()) lnseg = seg_[0].size() + seg_[1].size(); lcomm_->Broadcast(&lnseg,1,proc); // allocate vector to hold adjacency int offset = gmaxnnode+2; int size = lnseg*offset; std::vector<int> adj(size); // proc fills adjacency vector adj and broadcasts if (proc==lcomm_->MyPID()) { int count = 0; for (int side=0; side<2; ++side) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator scurr; for (scurr=seg_[side].begin(); scurr!=seg_[side].end(); ++scurr) { Teuchos::RCP<MOERTEL::Segment> seg = scurr->second; adj[count] = seg->Id(); adj[count+1] = seg->Nnode(); const int* ids = seg->NodeIds(); for (int i=0; i<seg->Nnode(); ++i) adj[count+2+i] = ids[i]; count += offset; } } } lcomm_->Broadcast(&adj[0],size,proc); // all procs read adj and add segment to the nodes they own int count = 0; for (int i=0; i<lnseg; ++i) { int segid = adj[count]; int nnode = adj[count+1]; for (int j=0; j<nnode; ++j) { int nid = adj[count+2+j]; if (lcomm_->MyPID() == NodePID(nid)) { // I own this node, so set the segment segid in it Teuchos::RCP<MOERTEL::Node> node = GetNodeViewLocal(nid); if (node == Teuchos::null) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** cannot find node " << nid << "\n" << "***ERR*** in map of all nodes on this proc\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } node->AddSegment(segid); } else continue; } count += offset; } adj.clear(); } // for (int proc=0; proc<lcomm_->NumProc(); ++proc) } // if (lComm()) //------------------------------------------------------------------- // build redundant segments and nodes if (lComm()) { int ok = 0; ok += RedundantSegments(0); ok += RedundantSegments(1); ok += RedundantNodes(0); ok += RedundantNodes(1); if (ok != 4) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** building of redundant information failed\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } } //------------------------------------------------------------------- // make topology segments <-> nodes for each side if (lComm()) BuildNodeSegmentTopology(); //------------------------------------------------------------------- // delete distributed nodes and segments for (int i=0; i<2; ++i) { seg_[i].clear(); node_[i].clear(); } //------------------------------------------------------------------- // we are done // note that there might not be any functions on the interface yet // they still have to be set return ok; }
double DeltaGibbs(int g,double *Delta,int Q,int G,const int *S,double c2, const double *tau2R,const double *b,const double *r, const double *sigma2,const double *phi, const int *psi,const double *x, const int *delta,const double *nu,Random &ran,int draw) { double pot = 0.0; // // compute prior covariance matrix // int dim = 0; std::vector<int> on(Q,0); int q; for (q = 0; q < Q; q++) { int kqg = qg2index(q,g,Q,G); if (delta[kqg] == 1) { on[q] = 1; dim++; } } if (dim > 0) { std::vector<std::vector<double> > var; makeSigma(g,G,var,on,Q,c2,tau2R,b,sigma2,r); // // define prior mean // std::vector<double> Mean(dim,0.0); std::vector<double> meanPrior(Mean); // // compute extra linear and quadratic terms // std::vector<double> mean(dim,0.0); std::vector<double> lin(dim,0.0); std::vector<double> quad(dim,0.0); int s; int k = 0; for (q = 0; q < Q; q++) { if (on[q] == 1) { int kqg = qg2index(q,g,Q,G); double var0 = sigma2[kqg] * phi[kqg]; double var1 = sigma2[kqg] / phi[kqg]; int s; for (s = 0; s < S[q]; s++) { int ksq = sq2index(s,q,S,Q); double variance = psi[ksq] == 0 ? var0 : var1; quad[k] += 1.0 / variance; int xIndex = sqg2index(s,q,g,S,Q,G); lin[k] += (2.0 * psi[ksq] - 1.0) * (x[xIndex] - nu[kqg]) / variance; } k++; } } // // Update parameters based on available observations // std::vector<std::vector<double> > varInv; double detPrior = inverse(var,varInv); std::vector<std::vector<double> > covInvPrior(varInv); for (k = 0; k < dim; k++) { Mean[k] += lin[k]; varInv[k][k] += quad[k]; } double detPosterior = 1.0 / inverse(varInv,var); matrixMult(var,Mean,mean); // // Draw new values // std::vector<double> vv(dim,0.0); if (draw == 1) vv = ran.MultiGaussian(var,mean); else { k = 0; for (q = 0; q < Q; q++) { if (on[q] == 1) { int kqg = qg2index(q,g,Q,G); vv[k] = Delta[kqg]; k++; } } } pot += ran.PotentialMultiGaussian(var,mean,vv); if (draw == 1) { k = 0; for (q = 0; q < Q; q++) { if (on[q] == 1) { int kqg = qg2index(q,g,Q,G); Delta[kqg] = vv[k]; k++; } } } } return pot; }
double nuGibbs(double *nu,int Q,int G,const int *S,double gamma2, const double *tau2Rho,const double *a,const double *rho, const double *sigma2,const double *phi, const int *psi,const double *x, const int *delta,const double *Delta,Random &ran,int draw) { double pot = 0.0; int g; for (g = 0; g < G; g++) { // // compute prior covariance matrix // std::vector<std::vector<double> > var; makeSigma(g,G,var,Q,gamma2,tau2Rho,a,sigma2,rho); // // define prior mean // std::vector<double> Mean(Q,0.0); // // compute extra linear and quadratic terms // std::vector<double> lin(Q,0.0); std::vector<double> quad(Q,0.0); int s; int q; for (q = 0; q < Q; q++) { int kqg = qg2index(q,g,Q,G); double var0 = sigma2[kqg] * phi[kqg]; double var1 = sigma2[kqg] / phi[kqg]; for (s = 0; s < S[q]; s++) { int ksq = sq2index(s,q,S,Q); double variance = psi[ksq] == 0 ? var0 : var1; quad[q] += 1.0 / variance; int ksqg = sqg2index(s,q,g,S,Q,G); lin[q] += (x[ksqg] - delta[kqg] * (2.0 * psi[ksq] - 1.0) * Delta[kqg]) / variance; } } // // Update parameters based on available observations // std::vector<std::vector<double> > varInv; double detPrior = inverse(var,varInv); for (q = 0; q < Q; q++) { varInv[q][q] += quad[q]; Mean[q] += lin[q]; } double detPosterior = 1.0 /inverse(varInv,var); std::vector<double> mean(Q,0.0); matrixMult(var,Mean,mean); // // Draw new values // std::vector<double> vv(Q,0.0); if (draw == 1) vv = ran.MultiGaussian(var,mean); else { for (q = 0; q < Q; q++) { int kqg = qg2index(q,g,Q,G); vv[q] = nu[kqg]; } } pot += ran.PotentialMultiGaussian(var,mean,vv); if (draw == 1) { for (q = 0; q < Q; q++) { int kqg = qg2index(q,g,Q,G); nu[kqg] = vv[q]; } } } return pot; }
int main(int argc, char* argv[]) { // Load the mesh. MeshSharedPtr u_mesh(new Mesh), v_mesh(new Mesh); MeshReaderH2DXML mloader; mloader.load("domain.xml", u_mesh); u_mesh->refine_all_elements(); v_mesh->copy(u_mesh); v_mesh->refine_towards_boundary("Bdy", INIT_REF_BDY); // Define right-hand sides. CustomRightHandSide1* g1 = new CustomRightHandSide1(K, D_u, SIGMA); CustomRightHandSide2* g2 = new CustomRightHandSide2(K, D_v); // Initialize the weak formulation. CustomWeakForm wf(g1, g2); // Initialize boundary conditions DefaultEssentialBCConst<double> bc_u("Bdy", 0.0); EssentialBCs<double> bcs_u(&bc_u); DefaultEssentialBCConst<double> bc_v("Bdy", 0.0); EssentialBCs<double> bcs_v(&bc_v); // Create H1 spaces with default shapeset for both displacement components. SpaceSharedPtr<double> u_space(new H1Space<double>(u_mesh, &bcs_u, P_INIT_U)); SpaceSharedPtr<double> v_space(new H1Space<double>(v_mesh, &bcs_v, P_INIT_V)); Hermes::vector<SpaceSharedPtr<double> > spaces(u_space, v_space); NewtonSolver<double> newton(&wf, spaces); MeshFunctionSharedPtr<double> u_sln(new Solution<double>()); MeshFunctionSharedPtr<double> u_sln1(new Solution<double>()); MeshFunctionSharedPtr<double> v_sln(new Solution<double>()); MeshFunctionSharedPtr<double> v_sln1(new Solution<double>()); Hermes::vector<MeshFunctionSharedPtr<double> > slns(u_sln, v_sln); Hermes::vector<MeshFunctionSharedPtr<double> > slns1(u_sln1, v_sln1); newton.solve(); Solution<double>::vector_to_solutions(newton.get_sln_vector(), spaces, slns); u_sln1->copy(u_sln); v_sln1->copy(v_sln); u_sln->free(); v_sln->free(); u_sln->copy(u_sln1); v_sln->copy(v_sln1); newton.solve(slns); Solution<double>::vector_to_solutions(newton.get_sln_vector(), spaces, slns1); Linearizer lin(FileExport); lin.process_solution(u_sln); lin.process_solution(u_sln1); lin.process_solution(v_sln1); lin.process_solution(u_sln1); lin.process_solution(u_sln1); lin.process_solution(v_sln1); return 0; }
void winfo::release_permanent(void) { QString fname,cclname; QByteArray sdat; if(client == NULL) return; if(qcbox[7]->isChecked()) // class only { cclname = client->get_clientname(); } else { cclname = res_name; cclname += ','; cclname += res_class; } if(defaults::cfdir.isNull()) { release_temporary(); return; } fname = defaults::cfdir; fname += "/appdefaults"; QFile apfile(fname); QList<QString> lns; if(apfile.open(QIODevice::ReadOnly)) { QTextStream lin(&apfile); while(! lin.atEnd()) { QString cln = lin.readLine(1024); if(cln.indexOf(cclname) != 0) lns.append(cln); } apfile.close(); } if(! apfile.open(QIODevice::WriteOnly)) { sdat = fname.toAscii(); perror(sdat.data()); release_temporary(); return; } for(int i=0; i < lns.size(); i++) { sdat = lns.at(i).toAscii(); sdat += '\n'; apfile.write(sdat.data(), sdat.length()); } int i; bool ref=FALSE; static const char *qcs[] = { "Sticky","WindowListSkip","SmallFrame","NoResize","NoTile","NoKey","NoScreen" }; QString ostr; for(i=0; i < 7; i++) { if(qcbox[i]->isChecked()) { if(! ref) { ostr = cclname; ostr += ' '; ref = TRUE; } else ostr = ','; ostr += qcs[i]; sdat = ostr.toAscii(); apfile.write(sdat.data(), sdat.length()); } } if(ref) apfile.write("\n", 1); apfile.close(); int tl = (client->get_pflags() & (WindowManager::NoTile|WindowManager::Sticky)); WindowManager::read_cprops(); if(WindowManager::is_tileddesk()) { if(tl && ! (client->get_pflags() & (WindowManager::NoTile|WindowManager::Sticky))) { WindowManager::tile_order(client); } else if(! tl && (client->get_pflags() & (WindowManager::NoTile|WindowManager::Sticky))) { WindowManager::tile_order(WindowManager::tmaxclient); client->raise(); } } release_cancel(); }