Python math.copysign() Examples
The following are 30
code examples of math.copysign().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
math
, or try the search function
.
Example #1
Source File: apted.py From apted with MIT License | 6 votes |
def get_strategy_path_type(self, strategy_path_id, size1, current): """Decodes the path from the optimal strategy to its type. Params: strategy_path_id: raw path id from strategy array. size1: offset used to distinguish between paths in the source and destination trees. it: node indexer current: current subtree processed in tree decomposition phase Return type of the strategy path: LEFT, RIGHT, INNER""" # pylint: disable=no-self-use if math.copysign(1, strategy_path_id) == -1: return LEFT path_id = abs(strategy_path_id) - 1 if path_id >= size1: path_id = path_id - size1 if path_id == (current.pre_ltr + current.size - 1): return RIGHT return INNER
Example #2
Source File: test_complex.py From BinderFilter with MIT License | 6 votes |
def assertFloatsAreIdentical(self, x, y): """assert that floats x and y are identical, in the sense that: (1) both x and y are nans, or (2) both x and y are infinities, with the same sign, or (3) both x and y are zeros, with the same sign, or (4) x and y are both finite and nonzero, and x == y """ msg = 'floats {!r} and {!r} are not identical' if isnan(x) or isnan(y): if isnan(x) and isnan(y): return elif x == y: if x != 0.0: return # both zero; check that signs match elif copysign(1.0, x) == copysign(1.0, y): return else: msg += ': zeros have different signs' self.fail(msg.format(x, y))
Example #3
Source File: yellowfin_backup.py From YellowFin_Pytorch with Apache License 2.0 | 6 votes |
def get_cubic_root(self): # We have the equation x^2 D^2 + (1-x)^4 * C / h_min^2 # where x = sqrt(mu). # We substitute x, which is sqrt(mu), with x = y + 1. # It gives y^3 + py = q # where p = (D^2 h_min^2)/(2*C) and q = -p. # We use the Vieta's substution to compute the root. # There is only one real solution y (which is in [0, 1] ). # http://mathworld.wolfram.com/VietasSubstitution.html # eps in the numerator is to prevent momentum = 1 in case of zero gradient p = (self._dist_to_opt + eps)**2 * (self._h_min + eps)**2 / 2 / (self._grad_var + eps) w3 = (-math.sqrt(p**2 + 4.0 / 27.0 * p**3) - p) / 2.0 w = math.copysign(1.0, w3) * math.pow(math.fabs(w3), 1.0/3.0) y = w - p / 3.0 / (w + eps) x = y + 1 if DEBUG: logging.debug("p %f, den %f", p, self._grad_var + eps) logging.debug("w3 %f ", w3) logging.debug("y %f, den %f", y, w + eps) return x
Example #4
Source File: test_complex.py From ironpython2 with Apache License 2.0 | 6 votes |
def assertFloatsAreIdentical(self, x, y): """assert that floats x and y are identical, in the sense that: (1) both x and y are nans, or (2) both x and y are infinities, with the same sign, or (3) both x and y are zeros, with the same sign, or (4) x and y are both finite and nonzero, and x == y """ msg = 'floats {!r} and {!r} are not identical' if isnan(x) or isnan(y): if isnan(x) and isnan(y): return elif x == y: if x != 0.0: return # both zero; check that signs match elif copysign(1.0, x) == copysign(1.0, y): return else: msg += ': zeros have different signs' self.fail(msg.format(x, y))
Example #5
Source File: test_formatting.py From ironpython2 with Apache License 2.0 | 6 votes |
def test_format_testfile(self): """the following is borrowed from stdlib""" import math format_testfile = 'formatfloat_testcases.txt' with open(os.path.join(self.test_dir, format_testfile)) as testfile: for line in testfile: print line if line.startswith('--'): continue line = line.strip() if not line: continue lhs, rhs = map(str.strip, line.split('->')) fmt, arg = lhs.split() arg = float(arg) self.assertEqual(fmt % arg, rhs) if not math.isnan(arg) and math.copysign(1.0, arg) > 0.0: print("minus") self.assertEqual(fmt % -arg, '-' + rhs)
Example #6
Source File: test_complex.py From oss-ftp with MIT License | 6 votes |
def assertFloatsAreIdentical(self, x, y): """assert that floats x and y are identical, in the sense that: (1) both x and y are nans, or (2) both x and y are infinities, with the same sign, or (3) both x and y are zeros, with the same sign, or (4) x and y are both finite and nonzero, and x == y """ msg = 'floats {!r} and {!r} are not identical' if isnan(x) or isnan(y): if isnan(x) and isnan(y): return elif x == y: if x != 0.0: return # both zero; check that signs match elif copysign(1.0, x) == copysign(1.0, y): return else: msg += ': zeros have different signs' self.fail(msg.format(x, y))
Example #7
Source File: _trustregion.py From lambda-packs with MIT License | 6 votes |
def get_boundaries_intersections(self, z, d, trust_radius): """ Solve the scalar quadratic equation ||z + t d|| == trust_radius. This is like a line-sphere intersection. Return the two values of t, sorted from low to high. """ a = np.dot(d, d) b = 2 * np.dot(z, d) c = np.dot(z, z) - trust_radius**2 sqrt_discriminant = math.sqrt(b*b - 4*a*c) # The following calculation is mathematically # equivalent to: # ta = (-b - sqrt_discriminant) / (2*a) # tb = (-b + sqrt_discriminant) / (2*a) # but produce smaller round off errors. # Look at Matrix Computation p.97 # for a better justification. aux = b + math.copysign(sqrt_discriminant, b) ta = -aux / (2*a) tb = -2*c / aux return sorted([ta, tb])
Example #8
Source File: _trustregion.py From GraphicDesignPatternByPython with MIT License | 6 votes |
def get_boundaries_intersections(self, z, d, trust_radius): """ Solve the scalar quadratic equation ||z + t d|| == trust_radius. This is like a line-sphere intersection. Return the two values of t, sorted from low to high. """ a = np.dot(d, d) b = 2 * np.dot(z, d) c = np.dot(z, z) - trust_radius**2 sqrt_discriminant = math.sqrt(b*b - 4*a*c) # The following calculation is mathematically # equivalent to: # ta = (-b - sqrt_discriminant) / (2*a) # tb = (-b + sqrt_discriminant) / (2*a) # but produce smaller round off errors. # Look at Matrix Computation p.97 # for a better justification. aux = b + math.copysign(sqrt_discriminant, b) ta = -aux / (2*a) tb = -2*c / aux return sorted([ta, tb])
Example #9
Source File: relativedelta.py From pipenv with MIT License | 5 votes |
def _sign(x): return int(copysign(1, x)) # vim:ts=4:sw=4:et
Example #10
Source File: function_test.py From Pytorch_Quantize_impls with MIT License | 5 votes |
def sign(x): return copysign(1, x)
Example #11
Source File: layer_test.py From Pytorch_Quantize_impls with MIT License | 5 votes |
def sign(x): return copysign(1, x)
Example #12
Source File: _multivariate.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def _givens_to_1(self, aii, ajj, aij): """Computes a 2x2 Givens matrix to put 1's on the diagonal for the input matrix. The input matrix is a 2x2 symmetric matrix M = [ aii aij ; aij ajj ]. The output matrix g is a 2x2 anti-symmetric matrix of the form [ c s ; -s c ]; the elements c and s are returned. Applying the output matrix to the input matrix (as b=g.T M g) results in a matrix with bii=1, provided tr(M) - det(M) >= 1 and floating point issues do not occur. Otherwise, some other valid rotation is returned. When tr(M)==2, also bjj=1. """ aiid = aii - 1. ajjd = ajj - 1. if ajjd == 0: # ajj==1, so swap aii and ajj to avoid division by zero return 0., 1. dd = math.sqrt(max(aij**2 - aiid*ajjd, 0)) # The choice of t should be chosen to avoid cancellation [1] t = (aij + math.copysign(dd, aij)) / ajjd c = 1. / math.sqrt(1. + t*t) if c == 0: # Underflow s = 1.0 else: s = c*t return c, s
Example #13
Source File: ticker.py From python3_ios with BSD 3-Clause "New" or "Revised" License | 5 votes |
def _compute_offset(self): locs = self.locs if locs is None or not len(locs): self.offset = 0 return # Restrict to visible ticks. vmin, vmax = sorted(self.axis.get_view_interval()) locs = np.asarray(locs) locs = locs[(vmin <= locs) & (locs <= vmax)] if not len(locs): self.offset = 0 return lmin, lmax = locs.min(), locs.max() # Only use offset if there are at least two ticks and every tick has # the same sign. if lmin == lmax or lmin <= 0 <= lmax: self.offset = 0 return # min, max comparing absolute values (we want division to round towards # zero so we work on absolute values). abs_min, abs_max = sorted([abs(float(lmin)), abs(float(lmax))]) sign = math.copysign(1, lmin) # What is the smallest power of ten such that abs_min and abs_max are # equal up to that precision? # Note: Internally using oom instead of 10 ** oom avoids some numerical # accuracy issues. oom_max = np.ceil(math.log10(abs_max)) oom = 1 + next(oom for oom in itertools.count(oom_max, -1) if abs_min // 10 ** oom != abs_max // 10 ** oom) if (abs_max - abs_min) / 10 ** oom <= 1e-2: # Handle the case of straddling a multiple of a large power of ten # (relative to the span). # What is the smallest power of ten such that abs_min and abs_max # are no more than 1 apart at that precision? oom = 1 + next(oom for oom in itertools.count(oom_max, -1) if abs_max // 10 ** oom - abs_min // 10 ** oom > 1) # Only use offset if it saves at least _offset_threshold digits. n = self._offset_threshold - 1 self.offset = (sign * (abs_max // 10 ** oom) * 10 ** oom if abs_max // 10 ** oom >= 10**n else 0)
Example #14
Source File: ticker.py From python3_ios with BSD 3-Clause "New" or "Revised" License | 5 votes |
def scale_range(vmin, vmax, n=1, threshold=100): dv = abs(vmax - vmin) # > 0 as nonsingular is called before. meanv = (vmax + vmin) / 2 if abs(meanv) / dv < threshold: offset = 0 else: offset = math.copysign(10 ** (math.log10(abs(meanv)) // 1), meanv) scale = 10 ** (math.log10(dv / n) // 1) return scale, offset
Example #15
Source File: yellowfin.py From YellowFin_Pytorch with Apache License 2.0 | 5 votes |
def get_cubic_root(self): # We have the equation x^2 D^2 + (1-x)^4 * C / h_min^2 # where x = sqrt(mu). # We substitute x, which is sqrt(mu), with x = y + 1. # It gives y^3 + py = q # where p = (D^2 h_min^2)/(2*C) and q = -p. # We use the Vieta's substution to compute the root. # There is only one real solution y (which is in [0, 1] ). # http://mathworld.wolfram.com/VietasSubstitution.html # eps in the numerator is to prevent momentum = 1 in case of zero gradient if np.isnan(self._dist_to_opt.cpu()) or np.isnan(self._h_min.cpu()) or np.isnan(self._grad_var) \ or np.isinf(self._dist_to_opt.cpu()) or np.isinf(self._h_min.cpu()) or np.isinf(self._grad_var): logging.warning("Input to cubic solver has invalid nan/inf value!") raise Exception("Input to cubic solver has invalid nan/inf value!") p = (self._dist_to_opt + eps)**2 * (self._h_min + eps)**2 / 2 / (self._grad_var + eps) w3 = (-math.sqrt(p**2 + 4.0 / 27.0 * p**3) - p) / 2.0 w = math.copysign(1.0, w3) * math.pow(math.fabs(w3), 1.0/3.0) y = w - p / 3.0 / (w + eps) x = y + 1 if self._verbose: logging.debug("p %f, denominator %f", p, self._grad_var + eps) logging.debug("w3 %f ", w3) logging.debug("y %f, denominator %f", y, w + eps) if np.isnan(x.cpu()) or np.isinf(x.cpu()): logging.warning("Output from cubic is invalid nan/inf value!") raise Exception("Output from cubic is invalid nan/inf value!") return x.item()
Example #16
Source File: codec.py From openelevationservice with Apache License 2.0 | 5 votes |
def _py2_round(x): # The polyline algorithm uses Python 2's way of rounding return int(math.copysign(math.floor(math.fabs(x) + 0.5), x))
Example #17
Source File: common.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def intersect_trust_region(x, s, Delta): """Find the intersection of a line with the boundary of a trust region. This function solves the quadratic equation with respect to t ||(x + s*t)||**2 = Delta**2. Returns ------- t_neg, t_pos : tuple of float Negative and positive roots. Raises ------ ValueError If `s` is zero or `x` is not within the trust region. """ a = np.dot(s, s) if a == 0: raise ValueError("`s` is zero.") b = np.dot(x, s) c = np.dot(x, x) - Delta**2 if c > 0: raise ValueError("`x` is not within the trust region.") d = np.sqrt(b*b - a*c) # Root from one fourth of the discriminant. # Computations below avoid loss of significance, see "Numerical Recipes". q = -(b + copysign(d, b)) t1 = q / a t2 = c / q if t1 < t2: return t1, t2 else: return t2, t1
Example #18
Source File: test_math.py From BinderFilter with MIT License | 5 votes |
def testTanh(self): self.assertRaises(TypeError, math.tanh) self.ftest('tanh(0)', math.tanh(0), 0) self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0) self.ftest('tanh(inf)', math.tanh(INF), 1) self.ftest('tanh(-inf)', math.tanh(NINF), -1) self.assertTrue(math.isnan(math.tanh(NAN))) # check that tanh(-0.) == -0. on IEEE 754 systems if float.__getformat__("double").startswith("IEEE"): self.assertEqual(math.tanh(-0.), -0.) self.assertEqual(math.copysign(1., math.tanh(-0.)), math.copysign(1., -0.))
Example #19
Source File: relativedelta.py From deepWordBug with Apache License 2.0 | 5 votes |
def _sign(x): return int(copysign(1, x)) # vim:ts=4:sw=4:et
Example #20
Source File: ticker.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def scale_range(vmin, vmax, n=1, threshold=100): dv = abs(vmax - vmin) # > 0 as nonsingular is called before. meanv = (vmax + vmin) / 2 if abs(meanv) / dv < threshold: offset = 0 else: offset = math.copysign(10 ** (math.log10(abs(meanv)) // 1), meanv) scale = 10 ** (math.log10(dv / n) // 1) return scale, offset
Example #21
Source File: ticker.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def _compute_offset(self): locs = self.locs # Restrict to visible ticks. vmin, vmax = sorted(self.axis.get_view_interval()) locs = np.asarray(locs) locs = locs[(vmin <= locs) & (locs <= vmax)] if not len(locs): self.offset = 0 return lmin, lmax = locs.min(), locs.max() # Only use offset if there are at least two ticks and every tick has # the same sign. if lmin == lmax or lmin <= 0 <= lmax: self.offset = 0 return # min, max comparing absolute values (we want division to round towards # zero so we work on absolute values). abs_min, abs_max = sorted([abs(float(lmin)), abs(float(lmax))]) sign = math.copysign(1, lmin) # What is the smallest power of ten such that abs_min and abs_max are # equal up to that precision? # Note: Internally using oom instead of 10 ** oom avoids some numerical # accuracy issues. oom_max = np.ceil(math.log10(abs_max)) oom = 1 + next(oom for oom in itertools.count(oom_max, -1) if abs_min // 10 ** oom != abs_max // 10 ** oom) if (abs_max - abs_min) / 10 ** oom <= 1e-2: # Handle the case of straddling a multiple of a large power of ten # (relative to the span). # What is the smallest power of ten such that abs_min and abs_max # are no more than 1 apart at that precision? oom = 1 + next(oom for oom in itertools.count(oom_max, -1) if abs_max // 10 ** oom - abs_min // 10 ** oom > 1) # Only use offset if it saves at least _offset_threshold digits. n = self._offset_threshold - 1 self.offset = (sign * (abs_max // 10 ** oom) * 10 ** oom if abs_max // 10 ** oom >= 10**n else 0)
Example #22
Source File: relativedelta.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def _sign(x): return int(copysign(1, x)) # vim:ts=4:sw=4:et
Example #23
Source File: client.py From ibis with Apache License 2.0 | 5 votes |
def _ibis_sqlite_sign(arg): if not arg: return 0 return math.copysign(1, arg)
Example #24
Source File: test_math.py From oss-ftp with MIT License | 5 votes |
def testTanh(self): self.assertRaises(TypeError, math.tanh) self.ftest('tanh(0)', math.tanh(0), 0) self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0) self.ftest('tanh(inf)', math.tanh(INF), 1) self.ftest('tanh(-inf)', math.tanh(NINF), -1) self.assertTrue(math.isnan(math.tanh(NAN))) # check that tanh(-0.) == -0. on IEEE 754 systems if float.__getformat__("double").startswith("IEEE"): self.assertEqual(math.tanh(-0.), -0.) self.assertEqual(math.copysign(1., math.tanh(-0.)), math.copysign(1., -0.))
Example #25
Source File: test_math.py From oss-ftp with MIT License | 5 votes |
def testCopysign(self): self.assertEqual(math.copysign(1, 42), 1.0) self.assertEqual(math.copysign(0., 42), 0.0) self.assertEqual(math.copysign(1., -42), -1.0) self.assertEqual(math.copysign(3, 0.), 3.0) self.assertEqual(math.copysign(4., -0.), -4.0) self.assertRaises(TypeError, math.copysign) # copysign should let us distinguish signs of zeros self.assertEqual(math.copysign(1., 0.), 1.) self.assertEqual(math.copysign(1., -0.), -1.) self.assertEqual(math.copysign(INF, 0.), INF) self.assertEqual(math.copysign(INF, -0.), NINF) self.assertEqual(math.copysign(NINF, 0.), INF) self.assertEqual(math.copysign(NINF, -0.), NINF) # and of infinities self.assertEqual(math.copysign(1., INF), 1.) self.assertEqual(math.copysign(1., NINF), -1.) self.assertEqual(math.copysign(INF, INF), INF) self.assertEqual(math.copysign(INF, NINF), NINF) self.assertEqual(math.copysign(NINF, INF), INF) self.assertEqual(math.copysign(NINF, NINF), NINF) self.assertTrue(math.isnan(math.copysign(NAN, 1.))) self.assertTrue(math.isnan(math.copysign(NAN, INF))) self.assertTrue(math.isnan(math.copysign(NAN, NINF))) self.assertTrue(math.isnan(math.copysign(NAN, NAN))) # copysign(INF, NAN) may be INF or it may be NINF, since # we don't know whether the sign bit of NAN is set on any # given platform. self.assertTrue(math.isinf(math.copysign(INF, NAN))) # similarly, copysign(2., NAN) could be 2. or -2. self.assertEqual(abs(math.copysign(2., NAN)), 2.)
Example #26
Source File: test_float.py From oss-ftp with MIT License | 5 votes |
def identical(self, x, y): # check that floats x and y are identical, or that both # are NaNs if isnan(x) or isnan(y): if isnan(x) == isnan(y): return elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)): return self.fail('%r not identical to %r' % (x, y))
Example #27
Source File: test_float.py From oss-ftp with MIT License | 5 votes |
def test_format_testfile(self): with open(format_testfile) as testfile: for line in open(format_testfile): if line.startswith('--'): continue line = line.strip() if not line: continue lhs, rhs = map(str.strip, line.split('->')) fmt, arg = lhs.split() arg = float(arg) self.assertEqual(fmt % arg, rhs) if not math.isnan(arg) and copysign(1.0, arg) > 0.0: self.assertEqual(fmt % -arg, '-' + rhs)
Example #28
Source File: test_float.py From oss-ftp with MIT License | 5 votes |
def assertEqualAndEqualSign(self, a, b): # fail unless a == b and a and b have the same sign bit; # the only difference from assertEqual is that this test # distinguishes -0.0 and 0.0. self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))
Example #29
Source File: order.py From pylivetrader with Apache License 2.0 | 5 votes |
def __init__(self, dt, asset, amount, stop=None, limit=None, filled=0, commission=0, id=None, ): """ @dt - datetime.datetime that the order was placed @asset - asset for the order. @amount - the number of shares to buy/sell a positive sign indicates a buy a negative sign indicates a sell @filled - how many shares of the order have been filled so far """ self.id = self.make_id() if id is None else id self.dt = dt self.reason = None self.created = dt self.asset = asset self.amount = amount self.filled = filled self.commission = commission self._status = ORDER_STATUS.OPEN self.stop = stop self.limit = limit self.stop_reached = False self.limit_reached = False self.direction = math.copysign(1, self.amount) # just make it None as it should not be used in live trade. self.type = None self.broker_order_id = None
Example #30
Source File: yellowfin.py From LightNet with MIT License | 5 votes |
def get_cubic_root(self): # We have the equation x^2 D^2 + (1-x)^4 * C / h_min^2 # where x = sqrt(mu). # We substitute x, which is sqrt(mu), with x = y + 1. # It gives y^3 + py = q # where p = (D^2 h_min^2)/(2*C) and q = -p. # We use the Vieta's substution to compute the root. # There is only one real solution y (which is in [0, 1] ). # http://mathworld.wolfram.com/VietasSubstitution.html # eps in the numerator is to prevent momentum = 1 in case of zero gradient if np.isnan(self._dist_to_opt) or np.isnan(self._h_min) or np.isnan(self._grad_var) \ or np.isinf(self._dist_to_opt) or np.isinf(self._h_min) or np.isinf(self._grad_var): logging.warning("Input to cubic solver has invalid nan/inf value!") raise Exception("Input to cubic solver has invalid nan/inf value!") p = (self._dist_to_opt + eps) ** 2 * (self._h_min + eps) ** 2 / 2 / (self._grad_var + eps) w3 = (-math.sqrt(p ** 2 + 4.0 / 27.0 * p ** 3) - p) / 2.0 w = math.copysign(1.0, w3) * math.pow(math.fabs(w3), 1.0 / 3.0) y = w - p / 3.0 / (w + eps) x = y + 1 if self._verbose: logging.debug("p %f, denominator %f", p, self._grad_var + eps) logging.debug("w3 %f ", w3) logging.debug("y %f, denominator %f", y, w + eps) if np.isnan(x) or np.isinf(x): logging.warning("Output from cubic is invalid nan/inf value!") raise Exception("Output from cubic is invalid nan/inf value!") return x