void RenderMathMLFraction::layoutBlock(bool relayoutChildren, LayoutUnit) { ASSERT(needsLayout()); if (!relayoutChildren && simplifiedLayout()) return; if (!isValid()) { setLogicalWidth(0); setLogicalHeight(0); clearNeedsLayout(); return; } numerator().layoutIfNeeded(); denominator().layoutIfNeeded(); setLogicalWidth(std::max(numerator().logicalWidth(), denominator().logicalWidth())); updateLineThickness(); LayoutUnit verticalOffset = 0; // This is the top of the renderer. LayoutPoint numeratorLocation(horizontalOffset(numerator(), element().numeratorAlignment()), verticalOffset); numerator().setLocation(numeratorLocation); LayoutUnit numeratorAscent = ascentForChild(numerator()); LayoutUnit numeratorDescent = numerator().logicalHeight() - numeratorAscent; LayoutUnit denominatorAscent = ascentForChild(denominator()); LayoutUnit denominatorDescent = denominator().logicalHeight() - denominatorAscent; if (isStack()) { LayoutUnit gapMin, topShiftUp, bottomShiftDown; getStackParameters(gapMin, topShiftUp, bottomShiftDown); LayoutUnit gap = topShiftUp - numeratorDescent + bottomShiftDown - denominatorAscent; if (gap < gapMin) { // If the gap is not large enough, we increase the shifts by the same value. LayoutUnit delta = (gapMin - gap) / 2; topShiftUp += delta; bottomShiftDown += delta; } verticalOffset += numeratorAscent + topShiftUp; // This is the middle of the stack gap. m_ascent = verticalOffset + mathAxisHeight(); verticalOffset += bottomShiftDown - denominatorAscent; } else { LayoutUnit numeratorGapMin, denominatorGapMin, numeratorMinShiftUp, denominatorMinShiftDown; getFractionParameters(numeratorGapMin, denominatorGapMin, numeratorMinShiftUp, denominatorMinShiftDown); verticalOffset += std::max(numerator().logicalHeight() + numeratorGapMin + m_lineThickness / 2, numeratorAscent + numeratorMinShiftUp); // This is the middle of the fraction bar. m_ascent = verticalOffset + mathAxisHeight(); verticalOffset += std::max(m_lineThickness / 2 + denominatorGapMin, denominatorMinShiftDown - denominatorAscent); } LayoutPoint denominatorLocation(horizontalOffset(denominator(), element().denominatorAlignment()), verticalOffset); denominator().setLocation(denominatorLocation); verticalOffset = std::max(verticalOffset + denominator().logicalHeight(), m_ascent + denominatorDescent); // This is the bottom of our renderer. setLogicalHeight(verticalOffset); clearNeedsLayout(); }
void pb_util::normalize(unsigned num_args, rational const* coeffs, rational const& k) { rational d(1); for (unsigned i = 0; i < num_args; ++i) { d = lcm(d, denominator(coeffs[i])); } m_coeffs.reset(); for (unsigned i = 0; i < num_args; ++i) { m_coeffs.push_back(d*coeffs[i]); } m_k = d*k; }
// returns string with numerator / denominator (e.g. "1/2") const std::string Fraction::asString( void ) { std::stringstream outStream; if (isValid()) outStream << numerator() << "/" << denominator(); else outStream << "Nan"; return std::string( outStream.str() ); }
unsigned TimeSigMap::raster(unsigned t, int raster) const { if (raster == 1) return t; auto e = upper_bound(t); if (e == end()) { qDebug("TimeSigMap::raster(%x,)", t); return t; } auto timesig = e->second.timesig(); return rasterEval(t, raster, e->first, timesig.numerator(), timesig.denominator(), raster / 2); }
int cmp(mpbq const & a, mpq const & b) { if (a.is_integer() && b.is_integer()) { return -cmp(b, a.m_num); } else { static thread_local mpz tmp1; static thread_local mpz tmp2; // tmp1 <- numerator(a)*denominator(b) denominator(tmp1, b); tmp1 *= a.m_num; // tmp2 <- numerator(b)*denominator(a) numerator(tmp2, b); mul2k(tmp2, tmp2, a.m_k); return cmp(tmp1, tmp2); } }
void mag(void) { save(); p1 = pop(); push(p1); numerator(); yymag(); push(p1); denominator(); yymag(); divide(); restore(); }
double EAPEstimator::estimateSE(Prior prior, size_t question, int answer) { const double theta_hat = estimateTheta(prior,question,answer); integrableFunction denominator = [&](double theta) { return likelihood(theta,question,answer) * prior.prior(theta); }; integrableFunction numerator = [&](double theta) { const double theta_difference = theta - theta_hat; return theta_difference * theta_difference * denominator(theta); }; return std::pow(integralQuotient(numerator, denominator, questionSet.lowerBound, questionSet.upperBound), 0.5); }
void pb_util::normalize(unsigned num_args, rational const* coeffs, rational const& k) { m_coeffs.reset(); bool all_ones = true; for (unsigned i = 0; i < num_args && all_ones; ++i) { all_ones = denominator(coeffs[i]).is_one(); } if (all_ones) { for (unsigned i = 0; i < num_args; ++i) { m_coeffs.push_back(coeffs[i]); } m_k = k; } else { rational d(1); for (unsigned i = 0; i < num_args; ++i) { d = lcm(d, denominator(coeffs[i])); } for (unsigned i = 0; i < num_args; ++i) { m_coeffs.push_back(d*coeffs[i]); } m_k = d*k; } }
Z3_ast Z3_API Z3_get_denominator(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_get_denominator(c, a); RESET_ERROR_CODE(); rational val; ast * _a = to_ast(a); if (!is_expr(_a) || !mk_c(c)->autil().is_numeral(to_expr(_a), val)) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); RETURN_Z3(nullptr); } expr * r = mk_c(c)->autil().mk_numeral(denominator(val), true); mk_c(c)->save_ast_trail(r); RETURN_Z3(of_expr(r)); Z3_CATCH_RETURN(nullptr); }
ptr tex::fin_mlist(ptr p) { ptr q; if (incompleat_noad != null) { math_type(denominator(incompleat_noad)) = SUB_MLIST; math_link(denominator(incompleat_noad)) = link(head); if (p == null) { q = incompleat_noad; } else { q = info(numerator(incompleat_noad)); if (type(q) != LEFT_NOAD) confusion("right"); math_link(numerator(incompleat_noad)) = link(q); link(q) = incompleat_noad; link(incompleat_noad) = p; } } else { link(tail) = p; q = link(head); } pop_nest(); return q; }
Foam::tmp<Foam::Field<Foam::scalar>> Foam::ParticleStressModels::HarrisCrighton::tau ( const Field<scalar>& alpha, const Field<scalar>& rho, const Field<scalar>& uSqr ) const { return ( pSolid_ * pow(alpha, beta_) / denominator(alpha) ); }
void RenderMathMLFraction::computePreferredLogicalWidths() { ASSERT(preferredLogicalWidthsDirty()); m_minPreferredLogicalWidth = 0; m_maxPreferredLogicalWidth = 0; if (isValid()) { LayoutUnit numeratorWidth = numerator().maxPreferredLogicalWidth(); LayoutUnit denominatorWidth = denominator().maxPreferredLogicalWidth(); m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = std::max(numeratorWidth, denominatorWidth); } setPreferredLogicalWidthsDirty(false); }
void tex::math_fraction () { int c; mcell garbage; c = cur_chr; if (incompleat_noad != null) { if (c >= DELIMITED_CODE) { scan_delimiter((ptr)&garbage, FALSE); scan_delimiter((ptr)&garbage, FALSE); } if (c % DELIMITED_CODE == ABOVE_CODE) scan_normal_dimen(); print_err("Ambiguous; you need another { and }"); help_fraction(); error(); } else { incompleat_noad = new_node(FRACTION_NOAD_SIZE); type(incompleat_noad) = FRACTION_NOAD; subtype(incompleat_noad) = NORMAL; math_type(numerator(incompleat_noad)) = SUB_MLIST; math_link(numerator(incompleat_noad)) = link(head); mzero(denominator(incompleat_noad)); mzero(left_delimiter(incompleat_noad)); mzero(right_delimiter(incompleat_noad)); link(head) = null; tail = head; if (c >= DELIMITED_CODE) { scan_delimiter(left_delimiter(incompleat_noad), FALSE); scan_delimiter(right_delimiter(incompleat_noad), FALSE); } switch (c % DELIMITED_CODE) { case ABOVE_CODE: scan_normal_dimen(); thickness(incompleat_noad) = cur_val; break; case OVER_CODE: thickness(incompleat_noad) = DEFAULT_CODE; break; case ATOP_CODE: thickness(incompleat_noad) = 0; break; } } }
Lisp_Object make_ratio(Lisp_Object p, Lisp_Object q) /* * By the time this is called (p/q) must be in its lowest terms, q>0 */ { Lisp_Object v, nil = C_nil; if (q == fixnum_of_int(1)) return p; stackcheck2(0, p, q); push2(p, q); v = getvector(TAG_NUMBERS, TYPE_RATNUM, sizeof(Rational_Number)); pop2(q, p); errexit(); numerator(v) = p; denominator(v) = q; return v; }
/* Computes a rational given a decimal string. The rational * version of <code>xxx.yyy</code> is <code>xxxyyy/(10^3)</code>. */ Rational Rational::fromDecimal(const std::string& dec) { // Find the decimal point, if there is one string::size_type i( dec.find(".") ); if( i != string::npos ) { /* Erase the decimal point, so we have just the numerator. */ Integer numerator( string(dec).erase(i,1) ); /* Compute the denominator: 10 raise to the number of decimal places */ int decPlaces = dec.size() - (i + 1); Integer denominator( Integer(10).pow(decPlaces) ); return Rational( numerator, denominator ); } else { /* No decimal point, assume it's just an integer. */ return Rational( dec ); } }
void spacer_matrix::normalize() { rational den = rational::one(); for (unsigned i=0; i < m_num_rows; ++i) { for (unsigned j=0; j < m_num_cols; ++j) { den = lcm(den, denominator(m_matrix[i][j])); } } for (unsigned i=0; i < m_num_rows; ++i) { for (unsigned j=0; j < m_num_cols; ++j) { m_matrix[i][j] = den * m_matrix[i][j]; SASSERT(m_matrix[i][j].is_int()); } } }
/** * Madara function that returns a random fraction between 0 and 1 **/ madara::knowledge::KnowledgeRecord rand_double (madara::knowledge::FunctionArguments & args, madara::knowledge::Variables & variables) { // empty arguments list to pass to rand_int (the function above) madara::knowledge::FunctionArguments rand_args; // the denominator is set to RAND_MAX madara::knowledge::KnowledgeRecord::Integer denominator (RAND_MAX); // the numerator is set to the results of rand () madara::knowledge::KnowledgeRecord numerator ( rand_int (rand_args, variables)); madara::knowledge::KnowledgeRecord result = numerator.to_double () / denominator; return result; }
double BinnedSharedPeakCount::operator()(const BinnedSpectrum& spec1, const BinnedSpectrum& spec2) const { if (!spec1.checkCompliance(spec2)) { cout << "incompatible" << endl; throw BinnedSpectrumCompareFunctor::IncompatibleBinning(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, ""); } // shortcut similarity calculation by comparing PrecursorPeaks (PrecursorPeaks more than delta away from each other are supposed to be from another peptide) double pre_mz1 = 0.0; if (!spec1.getRawSpectrum().getPrecursors().empty()) { pre_mz1 = spec1.getRawSpectrum().getPrecursors()[0].getMZ(); } double pre_mz2 = 0.0; if (!spec2.getRawSpectrum().getPrecursors().empty()) { pre_mz2 = spec2.getRawSpectrum().getPrecursors()[0].getMZ(); } if (fabs(pre_mz1 - pre_mz2) > precursor_mass_tolerance_) { return 0; } double score(0), sum(0); UInt denominator(max(spec1.getFilledBinNumber(), spec2.getFilledBinNumber())), shared_Bins(min(spec1.getBinNumber(), spec2.getBinNumber())); // all bins at equal position that have both intensity > 0 contribute positively to score for (Size i = 0; i < shared_Bins; ++i) { if (spec1.getBins()[i] > 0 && spec2.getBins()[i] > 0) { sum++; } } // resulting score normalized to interval [0,1] score = sum / denominator; return score; }
TransferFunction::TransferFunction(int x,int y) { mdl=new RectangleView(x,y); sNodeType="TransferFunction"; mosPath="Modelica.Blocks.Continuous.TransferFunction"; image_index = IM_TRANSFERFUNCTION; this->SetInputCount(1); this->SetOutputCount(1); this->SetInputsName(0, "u"); this->SetOutputsName(0, "y"); //参数初始化 para numerator("b","{1}","","传递函数的分子系数,示例:{1,-5}表示s-5"); //传函的分子系数 para denominator("a","{1,1}","","传递函数的分母系数"); //传函的分母系数 //加入参数列 para_List.push_back(numerator); para_List.push_back(denominator); }
bool set(mpbq & a, mpq const & b) { if (b.is_integer()) { numerator(a.m_num, b); a.m_k = 0; return true; } else { static thread_local mpz d; denominator(d, b); unsigned shift; if (d.is_power_of_two(shift)) { numerator(a.m_num, b); a.m_k = shift; lean_assert(a == b); return true; } else { numerator(a.m_num, b); a.m_k = d.log2() + 1; return false; } } }
Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_small(c, a, num, den); RESET_ERROR_CODE(); CHECK_IS_EXPR(a, Z3_FALSE); rational r; Z3_bool ok = Z3_get_numeral_rational(c, a, r); if (ok == Z3_TRUE) { rational n = numerator(r); rational d = denominator(r); if (n.is_int64() && d.is_int64()) { *num = n.get_int64(); *den = d.get_int64(); return Z3_TRUE; } else { return Z3_FALSE; } } SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); return Z3_FALSE; Z3_CATCH_RETURN(Z3_FALSE); }
void arctan(void) { double d; save(); p1 = pop(); if (car(p1) == symbol(TAN)) { push(cadr(p1)); restore(); return; } if (isdouble(p1)) { errno = 0; d = atan(p1->u.d); if (errno) stop("arctan function error"); push_double(d); restore(); return; } if (iszero(p1)) { push(zero); restore(); return; } if (isnegative(p1)) { push(p1); negate(); arctan(); negate(); restore(); return; } // arctan(sin(a) / cos(a)) ? if (find(p1, symbol(SIN)) && find(p1, symbol(COS))) { push(p1); numerator(); p2 = pop(); push(p1); denominator(); p3 = pop(); if (car(p2) == symbol(SIN) && car(p3) == symbol(COS) && equal(cadr(p2), cadr(p3))) { push(cadr(p2)); restore(); return; } } // arctan(1/sqrt(3)) -> pi/6 if (car(p1) == symbol(POWER) && equaln(cadr(p1), 3) && equalq(caddr(p1), -1, 2)) { push_rational(1, 6); push(symbol(PI)); multiply(); restore(); return; } // arctan(1) -> pi/4 if (equaln(p1, 1)) { push_rational(1, 4); push(symbol(PI)); multiply(); restore(); return; } // arctan(sqrt(3)) -> pi/3 if (car(p1) == symbol(POWER) && equaln(cadr(p1), 3) && equalq(caddr(p1), 1, 2)) { push_rational(1, 3); push(symbol(PI)); multiply(); restore(); return; } push_symbol(ARCTAN); push(p1); list(2); restore(); }
float cost_evaluator::eval(expr * f) const { #define E(IDX) eval(to_app(f)->get_arg(IDX)) if (is_app(f)) { unsigned num_args; family_id fid = to_app(f)->get_family_id(); if (fid == m_manager.get_basic_family_id()) { switch (to_app(f)->get_decl_kind()) { case OP_TRUE: return 1.0f; case OP_FALSE: return 0.0f; case OP_NOT: return E(0) == 0.0f ? 1.0f : 0.0f; case OP_AND: num_args = to_app(f)->get_num_args(); for (unsigned i = 0; i < num_args; i++) if (E(i) == 0.0f) return 0.0f; return 1.0f; case OP_OR: num_args = to_app(f)->get_num_args(); for (unsigned i = 0; i < num_args; i++) if (E(i) != 0.0f) return 1.0f; return 0.0f; case OP_ITE: return E(0) != 0.0f ? E(1) : E(2); case OP_EQ: case OP_IFF: return E(0) == E(1) ? 1.0f : 0.0f; case OP_XOR: return E(0) != E(1) ? 1.0f : 0.0f; case OP_IMPLIES: if (E(0) == 0.0f) return 1.0f; return E(1) != 0.0f ? 1.0f : 0.0f; default: ; } } else if (fid == m_util.get_family_id()) { switch (to_app(f)->get_decl_kind()) { case OP_NUM: { rational r = to_app(f)->get_decl()->get_parameter(0).get_rational(); return static_cast<float>(numerator(r).get_int64())/static_cast<float>(denominator(r).get_int64()); } case OP_LE: return E(0) <= E(1) ? 1.0f : 0.0f; case OP_GE: return E(0) >= E(1) ? 1.0f : 0.0f; case OP_LT: return E(0) < E(1) ? 1.0f : 0.0f; case OP_GT: return E(0) > E(1) ? 1.0f : 0.0f; case OP_ADD: return E(0) + E(1); case OP_SUB: return E(0) - E(1); case OP_UMINUS: return - E(0); case OP_MUL: return E(0) * E(1); case OP_DIV: { float q = E(1); if (q == 0.0f) { warning_msg("cost function division by zero"); return 1.0f; } return E(0) / q; } default: ; } } } else if (is_var(f)) { unsigned idx = to_var(f)->get_idx(); if (idx < m_num_args) return m_args[m_num_args - idx - 1]; } warning_msg("cost function evaluation error"); return 1.0f; }
void TimeDialog::nChanged(int /*val*/) { nText->setText(QString("%1").arg(denominator())); Fraction sig(zNominal->value(), denominator()); groups->setSig(sig, Groups::endings(sig)); }
static CSLbool numeqsr(Lisp_Object a, Lisp_Object b) /* * Here I will rely somewhat on the use of IEEE floating point values * (an in particular the weaker supposition that I have floating point * with a binary radix). Then for equality the denominator of b must * be a power of 2, which I can test for and then account for. */ { Lisp_Object nb = numerator(b), db = denominator(b); double d = float_of_number(a), d1; int x; int32_t dx, w, len; uint32_t u, bit; /* * first I will check that db (which will be positive) is a power of 2, * and set dx to indicate what power of two it is. * Note that db != 0 and that one of the top two words of a bignum * must be nonzero (for normalisation) so I end up with a nonzero * value in the variable 'bit' */ if (is_fixnum(db)) { bit = int_of_fixnum(db); w = bit; if (w != (w & (-w))) return NO; /* not a power of 2 */ dx = 0; } else if (is_numbers(db) && is_bignum(db)) { int32_t lenb = (bignum_length(db)-CELL-4)/4; bit = bignum_digits(db)[lenb]; /* * I need to cope with bignums where the leading digits is zero because * the 0x80000000 bit of the next word down is 1. To do this I treat * the number as having one fewer digits. */ if (bit == 0) bit = bignum_digits(db)[--lenb]; w = bit; if (w != (w & (-w))) return NO; /* not a power of 2 */ dx = 31*lenb; while (--lenb >= 0) /* check that the rest of db is zero */ if (bignum_digits(db)[lenb] != 0) return NO; } else return NO; /* Odd - what type IS db here? Maybe error. */ if ((bit & 0xffffU) == 0) dx += 16, bit = bit >> 16; if ((bit & 0xff) == 0) dx += 8, bit = bit >> 8; if ((bit & 0xf) == 0) dx += 4, bit = bit >> 4; if ((bit & 0x3) == 0) dx += 2, bit = bit >> 2; if ((bit & 0x1) == 0) dx += 1; if (is_fixnum(nb)) { double d1 = (double)int_of_fixnum(nb); /* * The ldexp on the next line could potentially underflow. In that case C * defines that the result 0.0 be returned. To avoid trouble I put in a * special test the relies on that fact that a value represented as a rational * would not have been zero. */ if (dx > 10000) return NO; /* Avoid gross underflow */ d1 = ldexp(d1, (int)-dx); return (d == d1 && d != 0.0); } len = (bignum_length(nb)-CELL-4)/4; if (len == 0) /* One word bignums can be treated specially */ { int32_t v = bignum_digits(nb)[0]; double d1; if (dx > 10000) return NO; /* Avoid gross underflow */ d1 = ldexp((double)v, (int)-dx); return (d == d1 && d != 0.0); } d1 = frexp(d, &x); /* separate exponent from mantissa */ if (d1 == 1.0) d1 = 0.5, x++; /* For Zortech */ dx += x; /* adjust to allow for the denominator */ d1 = ldexp(d1, (int)(dx % 31)); /* can neither underflow nor overflow here */ /* * At most 3 words in the bignum may contain nonzero data - I subtract * the (double) value of those bits off and check that (a) the floating * result left is zero and (b) there are no more bits left. */ dx = dx / 31; if (dx != len) return NO; w = bignum_digits(nb)[len]; d1 = (d1 - (double)w) * TWO_31; u = bignum_digits(nb)[--len]; d1 = (d1 - (double)u) * TWO_31; if (len > 0) { u = bignum_digits(nb)[--len]; d1 = d1 - (double)u; } if (d1 != 0.0) return NO; while (--len >= 0) if (bignum_digits(nb)[len] != 0) return NO; return YES; }
static CSLbool numeqrr(Lisp_Object a, Lisp_Object b) { return numeq2(numerator(a), numerator(b)) && numeq2(denominator(a), denominator(b)); }
std::shared_ptr<AVFrame> make_av_video_frame(const core::const_frame& frame, const core::video_format_desc& format_desc) { auto av_frame = alloc_frame(); auto pix_desc = frame.pixel_format_desc(); auto planes = pix_desc.planes; auto format = pix_desc.format; const auto sar = boost::rational<int>(format_desc.square_width, format_desc.square_height) / boost::rational<int>(format_desc.width, format_desc.height); av_frame->sample_aspect_ratio = {sar.numerator(), sar.denominator()}; av_frame->width = format_desc.width; av_frame->height = format_desc.height; switch (format) { case core::pixel_format::rgb: av_frame->format = AVPixelFormat::AV_PIX_FMT_RGB24; break; case core::pixel_format::bgr: av_frame->format = AVPixelFormat::AV_PIX_FMT_BGR24; break; case core::pixel_format::rgba: av_frame->format = AVPixelFormat::AV_PIX_FMT_RGBA; break; case core::pixel_format::argb: av_frame->format = AVPixelFormat::AV_PIX_FMT_ARGB; break; case core::pixel_format::bgra: av_frame->format = AVPixelFormat::AV_PIX_FMT_BGRA; break; case core::pixel_format::abgr: av_frame->format = AVPixelFormat::AV_PIX_FMT_ABGR; break; case core::pixel_format::gray: av_frame->format = AVPixelFormat::AV_PIX_FMT_GRAY8; break; case core::pixel_format::ycbcr: { int y_w = planes[0].width; int y_h = planes[0].height; int c_w = planes[1].width; int c_h = planes[1].height; if (c_h == y_h && c_w == y_w) av_frame->format = AVPixelFormat::AV_PIX_FMT_YUV444P; else if (c_h == y_h && c_w * 2 == y_w) av_frame->format = AVPixelFormat::AV_PIX_FMT_YUV422P; else if (c_h == y_h && c_w * 4 == y_w) av_frame->format = AVPixelFormat::AV_PIX_FMT_YUV411P; else if (c_h * 2 == y_h && c_w * 2 == y_w) av_frame->format = AVPixelFormat::AV_PIX_FMT_YUV420P; else if (c_h * 2 == y_h && c_w * 4 == y_w) av_frame->format = AVPixelFormat::AV_PIX_FMT_YUV410P; break; } case core::pixel_format::ycbcra: av_frame->format = AVPixelFormat::AV_PIX_FMT_YUVA420P; break; } FF(av_frame_get_buffer(av_frame.get(), 32)); // TODO (perf) Avoid extra memcpy. for (int n = 0; n < planes.size(); ++n) { for (int y = 0; y < av_frame->height; ++y) { std::memcpy(av_frame->data[n] + y * av_frame->linesize[n], frame.image_data(n).data() + y * planes[n].linesize, planes[n].linesize); } } return av_frame; }
Polynom::Polynom(const string str) { int tmp, tmp1, tmp2; coefficients.clear(); if (str.length() < 8) throw(invalid_argument("incorrect number input. You can try help\n")); for (auto i = 0; i < str.length(); i++) if (!isdigit(str[i]) && str[i] != 'x' && str[i] != '^' && str[i] != '+' && str[i] != '-' && str[i] != '/' && str[i] != '(' && str[i] != ')') throw(invalid_argument("incorrect number input. You can try help\n")); tmp = 0; if (str[0] == '-' || str[0] == '+') tmp++; do { tmp1 = str.find("(", tmp); if (tmp1 != tmp) throw(invalid_argument("incorrect number input. You can try help\n")); tmp = ++tmp1; while (tmp < str.size() && isdigit(str[tmp])) tmp++; if (tmp == tmp1) throw(invalid_argument("incorrect number input. You can try help\n")); if (tmp != -1) { tmp1 = str.find("/", tmp); if (tmp1 == -1 || (tmp1 - tmp) != 0) throw(invalid_argument("incorrect number input. You can try help\n")); tmp = ++tmp1; while (tmp < str.size() && isdigit(str[tmp])) tmp++; if (tmp == tmp1) throw(invalid_argument("incorrect number input. You can try help\n")); tmp1 = str.find(")", tmp); if (tmp1 == -1 || (tmp1 - tmp) != 0) throw(invalid_argument("incorrect number input. You can try help\n")); tmp = ++tmp1; tmp1 = str.find("x^", tmp); if (tmp1 == -1 || (tmp1 - tmp) != 0) throw(invalid_argument("incorrect number input. You can try help\n")); tmp1 += 2; while (tmp1 < str.size() && isdigit(str[tmp1])) tmp1++; if (tmp == tmp1) throw(invalid_argument("incorrect number input. You can try help\n")); if (tmp1 == str.size()) break; tmp2 = tmp = tmp1; tmp = str.find("+", tmp); tmp1 = str.find("-", tmp1); if (tmp == -1 && tmp1 == -1) throw(invalid_argument("incorrect number input. You can try help\n")); if (tmp == -1) tmp = tmp1; if (tmp1 < tmp) tmp = tmp1; if ((tmp - tmp2) != 0) throw(invalid_argument("incorrect number input. You can try help\n")); tmp++; } else throw(invalid_argument("incorrect number input. You can try help\n")); } while (true); MegaNatural lastCoef,b_lastCoef; int sign; MegaRational coef(); bool first = true; int pos = 0; do { if (first) { first = false; if (str[0] == '-') sign = -1; else sign = 1; MegaInteger numerator(getNextNum(str, pos)); numerator = numerator*(MegaInteger)(-1); MegaNatural denominator(getNextNum(str, pos)); coefficients.push_front(MegaRational(numerator, denominator)); lastCoef = getNextNum(str, pos); continue; } tmp = str.find("+", pos); tmp1 = str.find("-", pos); if (tmp == -1 && tmp1 == -1) break; if (tmp != -1 && tmp1 != -1) if (tmp < tmp1) sign = 1; else sign = -1; if (tmp == -1) sign = -1; if (tmp1 == -1) sign = 1; MegaInteger numerator(getNextNum(str, pos)); numerator = numerator*(MegaInteger) (-1); MegaNatural denominator(getNextNum(str, pos)); coefficients.push_front(MegaRational(numerator, denominator)); b_lastCoef = lastCoef; lastCoef = getNextNum(str, pos); if (lastCoef >= b_lastCoef) { coefficients.clear(); coefficients.resize(0); throw(invalid_argument("incorrect number input. You can try help\n")); } else { while ((b_lastCoef - (MegaNatural) 1) > lastCoef) { b_lastCoef = b_lastCoef - (MegaNatural) 1; coefficients.push_front(MegaRational()); } } } while (pos < str.size()); while (lastCoef>(MegaNatural)0) { lastCoef = lastCoef - (MegaNatural)1; coefficients.push_front(MegaRational()); } }
sample_rate sample_rate::common( const sample_rate &o ) const { auto x = _ratio.common( o._ratio ); return sample_rate( x.numerator(), x.denominator() ); }
void manualFRTest() { TFile* f = TFile::Open("/eos/user/v/vischia/www/taufakes_new/plotter_wjet.root", "READ"); TString data("data (single mu)"), ttbar("TTbar"), wjets("W#rightarrow l#nu inclusive"), qcd("QCD_EMEnr_Incl"); TString numerator("/wjet_step5byLooseCombinedIsolationDeltaBetaCorr3Hitseta_numerator"), denominator("/wjet_step5eta_denominator"); TH1F* data_num = (TH1F*) f->Get(data+numerator); TH1F* data_den = (TH1F*) f->Get(data+denominator); TH1F* ttbar_num = (TH1F*) f->Get(ttbar+numerator); TH1F* ttbar_den = (TH1F*) f->Get(ttbar+denominator); TH1F* wjets_num = (TH1F*) f->Get(wjets+numerator); TH1F* wjets_den = (TH1F*) f->Get(wjets+denominator); TH1F* qcd_num = (TH1F*) f->Get(qcd+numerator); TH1F* qcd_den = (TH1F*) f->Get(qcd+denominator); TH1F* mc_num = (TH1F*) ttbar_num->Clone("mc_num"); mc_num->Add(wjets_num); //mc_num->Add(qcd_num); TH1F* mc_den = (TH1F*) ttbar_den->Clone("mc_den"); mc_den->Add(wjets_den); //mc_den->Add(qcd_den); data_num->SetMarkerColor(kBlack); mc_num->SetMarkerColor(kRed); data_den->SetMarkerColor(kBlack); mc_den->SetMarkerColor(kRed); TCanvas* d = new TCanvas("d", "d", 600, 1200); d->Divide(1,2); d->cd(1); gPad->SetTitle("numerator"); data_num->DrawCopy("pe"); mc_num->DrawCopy("pesame"); d->cd(2); gPad->SetTitle("denominator"); data_den->DrawCopy("pe"); mc_den->DrawCopy("pesame"); TH1F* data_fr = (TH1F*) data_num->Clone("data_fr"); data_fr->Divide(data_den); TH1F* mc_fr = (TH1F*) mc_num->Clone("mc_fr"); mc_fr->Divide(mc_den); data_fr->SetMarkerColor(kBlack); mc_fr->SetMarkerColor(kRed); data_fr->SetMarkerSize(2); mc_fr->SetMarkerSize(2); TCanvas* c = new TCanvas("c", "c", 600, 600); c->cd(); data_fr->Draw("pe"); mc_fr->Draw("pesame"); }