/** * @brief Find the biggest common step from a set of all steps. */ std::size_t greatestCommonDivisor( const std::set<std::size_t>& steps ) { if( steps.size() == 1 ) { return *steps.begin(); } std::set<std::size_t> allSteps; for( std::set<std::size_t>::const_iterator itA = steps.begin(), itB = ++steps.begin(), itEnd = steps.end(); itB != itEnd; ++itA, ++itB ) { allSteps.insert( greatestCommonDivisor( *itB, *itA ) ); } return greatestCommonDivisor( allSteps ); }
inline stick::Int64 greatestCommonDivisor(stick::Int64 _a, stick::Int64 _b) { if (_b == 0) return _a; return greatestCommonDivisor(_b, _a % _b); }
inline int greatestCommonDivisor(int _a, int _b) { if (_b == 0) return _a; return greatestCommonDivisor(_b, _a % _b); }
inline T greatestCommonDivisor(T _a, T _b) { if (_b == 0) return _a; return greatestCommonDivisor(_b, std::fmod(_a, _b)); }
void setInitialCounter(rowcount_t prevRecCount) { if (numerator) { IHThorEnthArg * helper = static_cast <IHThorEnthArg *> (queryHelper()); if(denominator == 0) denominator = 1; counter = (rowcount_t)((helper->getSampleNumber()-1) * greatestCommonDivisor(numerator, denominator)); if (counter >= denominator) counter %= denominator; rowcount_t maxBatch = (RCMAX - denominator) / numerator; while (prevRecCount > 0) { rowcount_t next = prevRecCount; if (next > maxBatch) next = maxBatch; counter = (counter + next * numerator) % denominator; prevRecCount -= next; } } else abortSoon = true; #if THOR_TRACE_LEVEL >= 5 ActPrintLog("ENTH: init - Numerator = %"RCPF"d, Denominator = %"RCPF"d", numerator, denominator); ActPrintLog("%s: Initial value of counter %"RCPF"d", actStr.str(), counter); #endif }
int RatioLayoutedFrame::greatestCommonDivisor(int a, int b) { if (b==0) { return a; } return greatestCommonDivisor(b, a % b); }
void RatioLayoutedFrame::setAspectRatio(unsigned short width, unsigned short height) { int divisor = greatestCommonDivisor(width, height); if (divisor != 0) { aspect_ratio_.setWidth(width / divisor); aspect_ratio_.setHeight(height / divisor); } }
// Returns the size of the video IntSize MediaPlayerPrivateGStreamerBase::naturalSize() const { if (!hasVideo()) return IntSize(); if (!m_videoSize.isEmpty()) return m_videoSize; GRefPtr<GstCaps> caps = currentVideoSinkCaps(); if (!caps) return IntSize(); // TODO: handle possible clean aperture data. See // https://bugzilla.gnome.org/show_bug.cgi?id=596571 // TODO: handle possible transformation matrix. See // https://bugzilla.gnome.org/show_bug.cgi?id=596326 // Get the video PAR and original size, if this fails the // video-sink has likely not yet negotiated its caps. int pixelAspectRatioNumerator, pixelAspectRatioDenominator, stride; IntSize originalSize; GstVideoFormat format; if (!getVideoSizeAndFormatFromCaps(caps.get(), originalSize, format, pixelAspectRatioNumerator, pixelAspectRatioDenominator, stride)) return IntSize(); LOG_MEDIA_MESSAGE("Original video size: %dx%d", originalSize.width(), originalSize.height()); LOG_MEDIA_MESSAGE("Pixel aspect ratio: %d/%d", pixelAspectRatioNumerator, pixelAspectRatioDenominator); // Calculate DAR based on PAR and video size. int displayWidth = originalSize.width() * pixelAspectRatioNumerator; int displayHeight = originalSize.height() * pixelAspectRatioDenominator; // Divide display width and height by their GCD to avoid possible overflows. int displayAspectRatioGCD = greatestCommonDivisor(displayWidth, displayHeight); displayWidth /= displayAspectRatioGCD; displayHeight /= displayAspectRatioGCD; // Apply DAR to original video size. This is the same behavior as in xvimagesink's setcaps function. guint64 width = 0, height = 0; if (!(originalSize.height() % displayHeight)) { LOG_MEDIA_MESSAGE("Keeping video original height"); width = gst_util_uint64_scale_int(originalSize.height(), displayWidth, displayHeight); height = static_cast<guint64>(originalSize.height()); } else if (!(originalSize.width() % displayWidth)) { LOG_MEDIA_MESSAGE("Keeping video original width"); height = gst_util_uint64_scale_int(originalSize.width(), displayHeight, displayWidth); width = static_cast<guint64>(originalSize.width()); } else { LOG_MEDIA_MESSAGE("Approximating while keeping original video height"); width = gst_util_uint64_scale_int(originalSize.height(), displayWidth, displayHeight); height = static_cast<guint64>(originalSize.height()); } LOG_MEDIA_MESSAGE("Natural size: %" G_GUINT64_FORMAT "x%" G_GUINT64_FORMAT, width, height); m_videoSize = IntSize(static_cast<int>(width), static_cast<int>(height)); return m_videoSize; }
rational rational::operator* (const rational& second) const{ rational result; result.denom = this -> denom * second.denom; result.num = this -> num * second.num; int gcd = greatestCommonDivisor(result.num,result.denom); result.num = result.num / gcd; result.denom = result.denom /gcd; return result; }
rational rational::operator- (const rational& second) const{ rational result; result.denom = this -> denom * second.denom; int multi_first = result.denom / this -> denom; int multi_sec = result.denom / second.denom; result.num = (this -> num * multi_first) - (second.num * multi_sec); int gcd = greatestCommonDivisor(result.num , result.denom); int temp = result.num; result.num = temp / gcd; temp = result.denom; result.denom = temp / gcd; return result; }
rational::rational(int n, int d){ num = n; denom =d; if ((denom < 0) && (num > 0)) { num = -num; denom = -denom; } int gcd = greatestCommonDivisor(num, denom); num = num / gcd; denom = denom / gcd; }
void DisplaySettingsDialog::fillResolutions() { ui.comboBoxReso->clear(); const QList<QSize> resos = screen.availableResolutions(); foreach (const QSize& reso, resos) { QSize ratio = reso / greatestCommonDivisor(reso.width(), reso.height()); QString text = tr("%1 x %2 (%3:%4)") .arg(reso.width()).arg(reso.height()) .arg(ratio.width()).arg(ratio.height()); ui.comboBoxReso->addItem(text, reso); }
/** * @brief Extract step from a sorted vector of time values. */ std::size_t extractStep( const std::vector<Time>& times ) { if( times.size() <= 1 ) { return 1; } std::set<std::size_t> allSteps; for( std::vector<Time>::const_iterator itA = times.begin(), itB = ++times.begin(), itEnd = times.end(); itB != itEnd; ++itA, ++itB ) { allSteps.insert( *itB - *itA ); } return greatestCommonDivisor( allSteps ); }
/** * @brief Extract step from a sorted vector of time values. */ std::size_t extractStep( const std::vector<detail::FileNumbers>::const_iterator& timesBegin, const std::vector<detail::FileNumbers>::const_iterator& timesEnd, const std::size_t i ) { if( std::distance( timesBegin, timesEnd ) <= 1 ) { return 1; } std::set<std::size_t> allSteps; for( std::vector<detail::FileNumbers>::const_iterator itA = timesBegin, itB = boost::next(timesBegin), itEnd = timesEnd; itB != itEnd; ++itA, ++itB ) { allSteps.insert( itB->getTime( i ) - itA->getTime( i ) ); } return greatestCommonDivisor( allSteps ); }
/** * @brief Find the biggest common step from a set of all steps. */ void Sequence::extractStep( const std::set<std::size_t>& steps ) { if( steps.size() == 1 ) { _step = *steps.begin(); return; } std::set<std::size_t> allSteps; for( std::set<std::size_t>::const_iterator itA = steps.begin(), itB = ++steps.begin(), itEnd = steps.end(); itB != itEnd; ++itA, ++itB ) { allSteps.insert( greatestCommonDivisor( *itB, *itA ) ); } extractStep( allSteps ); }
static int32_t leastCommonMultiple(int32_t a, int32_t b, int32_t &result) { return safeMultiply(a, b / greatestCommonDivisor(a, b), result); }
static int greatestCommonDivisor(int a, int b) { if (b == 0) return a; return greatestCommonDivisor(b, a % b); }
unsigned long greatestCommonDivisor( unsigned long a, unsigned long b ) { return b == 0 ? a : greatestCommonDivisor( b, a%b); }