Lines Matching +full:da +full:- +full:f
4 """Fraction, infinite-precision, real numbers."""
25 (?P<sign>[-+]?) # an optional sign, then
32 (?:E(?P<exp>[-+]?\d+))? # and optional exponent
41 In the two-argument form of the constructor, Fraction(8, 6) will
48 - numeric strings similar to those accepted by the
49 float constructor (for example, '-2.3' or '1e10')
51 - strings of the form '123/456'
53 - float and Decimal instances
55 - other Rational instances (including integers)
69 --------
71 >>> Fraction(10, -8)
72 Fraction(-5, 4)
79 >>> Fraction('-35/4')
80 Fraction(-35, 4)
83 >>> Fraction('-47e-2') # string may include a decimal exponent
84 Fraction(-47, 100)
134 denominator *= 10**-exp
135 if m.group('sign') == '-':
136 numerator = -numerator
160 g = -g
168 def from_float(cls, f): argument
174 if isinstance(f, numbers.Integral):
175 return cls(f)
176 elif not isinstance(f, float):
178 (cls.__name__, f, type(f).__name__))
179 return cls(*f.as_integer_ratio())
230 # two integers) the lower bound---i.e., the floor of self, is
246 n, d = d, n-a*d
248 k = (max_denominator-q0)//q1
251 if abs(bound2 - self) <= abs(bound1-self):
277 """Generates forward and reverse operators given a purely-rational
284 that mixed-mode operations either call an implementation whose
319 There are 5 different cases for a mixed-type addition on
389 # Let g = gcd(da, db). Then
391 # na nb na*db ± nb*da
392 # a ± b == -- ± -- == ------------- ==
393 # da db da*db
395 # na*(db//g) ± nb*(da//g) t
396 # == ----------------------- == -
397 # (da*db)//g d
401 # Note, that t, (da//g) and (db//g) are pairwise coprime.
403 # Indeed, (da//g) and (db//g) share no common factors (they were
404 # removed) and da is coprime with na (since input fractions are
405 # normalized), hence (da//g) and na are coprime. By symmetry,
408 # gcd(t, da//g) == gcd(na*(db//g), da//g) == 1
409 # gcd(t, db//g) == gcd(nb*(da//g), db//g) == 1
414 # g2 = gcd(t, d) == gcd(t, (da//g)*(db//g)*g) == gcd(t, g)
417 # a ± b == ----------------------- == ----------------
418 # (da//g)*(db//g)*(g//g2) (da//g)*(db//g2)
423 # We should special-case g == 1 (and g2 == 1), since 60.8% of
424 # randomly-chosen integers are coprime:
431 # Let g1 = gcd(na, db) and g2 = gcd(nb, da), then
434 # a*b == ----- == ----- == -----------------
435 # da*db db*da (db//g1)*(da//g2)
443 # Indeed, pick (na//g1). It's coprime with (da//g2), because input
447 # As for addition/subtraction, we should special-case g1 == 1
453 na, da = a.numerator, a.denominator
455 g = math.gcd(da, db)
457 return Fraction(na * db + da * nb, da * db, _normalize=False)
458 s = da // g
468 """a - b"""
469 na, da = a.numerator, a.denominator
471 g = math.gcd(da, db)
473 return Fraction(na * db - da * nb, da * db, _normalize=False)
474 s = da // g
475 t = na * (db // g) - nb * s
485 na, da = a.numerator, a.denominator
491 g2 = math.gcd(nb, da)
494 da //= g2
495 return Fraction(na * nb, db * da, _normalize=False)
502 na, da = a.numerator, a.denominator
508 g2 = math.gcd(db, da)
510 da //= g2
512 n, d = na * db, nb * da
514 n, d = -n, -d
527 da, db = a.denominator, b.denominator
528 div, n_mod = divmod(a.numerator * db, da * b.numerator)
529 return div, Fraction(n_mod, da * db)
535 da, db = a.denominator, b.denominator
536 return Fraction((a.numerator * db) % (b.numerator * da), da * db)
556 return Fraction(a._denominator ** -power,
557 a._numerator ** -power,
560 return Fraction((-a._denominator) ** -power,
561 (-a._numerator) ** -power,
589 """-a"""
590 return Fraction(-a._numerator, a._denominator, _normalize=False)
599 return -(-a._numerator // a._denominator)
610 return -(-a.numerator // a.denominator)
643 # documentation. (See library docs, 'Built-in Types').
646 dinv = pow(self._denominator, -1, _PyHASH_MODULUS)
655 # optimized here in two ways: first, for a non-negative int i,
667 result = hash_ if self._numerator >= 0 else -hash_
668 return -2 if result == -1 else result
731 # bpo-39274: Use bool() because (a._numerator != 0) can return an