Python numbers.Complex() Examples
The following are 30
code examples of numbers.Complex().
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
numbers
, or try the search function
.
Example #1
Source File: namelist.py From f90nml with Apache License 2.0 | 6 votes |
def _f90repr(self, value): """Convert primitive Python types to equivalent Fortran strings.""" if isinstance(value, bool): return self._f90bool(value) elif isinstance(value, numbers.Integral): return self._f90int(value) elif isinstance(value, numbers.Real): return self._f90float(value) elif isinstance(value, numbers.Complex): return self._f90complex(value) elif isinstance(value, basestring): return self._f90str(value) elif value is None: return '' else: raise ValueError('Type {0} of {1} cannot be converted to a Fortran' ' type.'.format(type(value), value))
Example #2
Source File: fractions.py From CTFCrackTools-V2 with GNU General Public License v3.0 | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #3
Source File: fractions.py From BinderFilter with MIT License | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #4
Source File: compat.py From auto-alt-text-lambda-api with MIT License | 6 votes |
def as_str_any(value): """Converts to `str` as `str(value)`, but use `as_str` for `bytes`. Args: value: A object that can be converted to `str`. Returns: A `str` object. """ if isinstance(value, bytes): return as_str(value) else: return str(value) # Numpy 1.8 scalars don't inherit from numbers.Integral in Python 3, so we # need to check them specifically. The same goes from Real and Complex.
Example #5
Source File: fractions.py From RevitBatchProcessor with GNU General Public License v3.0 | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #6
Source File: fractions.py From meddle with MIT License | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #7
Source File: compat.py From lambda-packs with MIT License | 6 votes |
def as_str_any(value): """Converts to `str` as `str(value)`, but use `as_str` for `bytes`. Args: value: A object that can be converted to `str`. Returns: A `str` object. """ if isinstance(value, bytes): return as_str(value) else: return str(value) # Numpy 1.8 scalars don't inherit from numbers.Integral in Python 3, so we # need to check them specifically. The same goes from Real and Complex.
Example #8
Source File: fractions.py From ironpython2 with Apache License 2.0 | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #9
Source File: fractions.py From CTFCrackTools-V2 with GNU General Public License v3.0 | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #10
Source File: Facade.py From nionswift with GNU General Public License v3.0 | 6 votes |
def set_input_value(self, name: str, value): # support lists here? if isinstance(value, (str, bool, numbers.Integral, numbers.Real, numbers.Complex)): self.__computation.set_input_value(name, value) if isinstance(value, dict) and value.get("object"): object = value.get("object") object_type = value.get("type") if object_type == "data_source": document_model = self.__computation.container.container.container.container display_item = document_model.get_display_item_for_data_item(object._data_item) display_data_channel = display_item.display_data_channel input_value = Symbolic.make_item(display_data_channel) else: input_value = Symbolic.make_item(object._item) self.__computation.set_input_item(name, input_value) elif hasattr(value, "_item"): input_value = Symbolic.make_item(value._item) self.__computation.set_input_item(name, input_value)
Example #11
Source File: fractions.py From Computable with MIT License | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #12
Source File: fractions.py From odoo13-x64 with GNU General Public License v3.0 | 6 votes |
def __eq__(a, b): """a == b""" if type(b) is int: return a._numerator == b and a._denominator == 1 if isinstance(b, numbers.Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #13
Source File: fractions.py From Project-New-Reign---Nemesis-Main with GNU General Public License v3.0 | 6 votes |
def __eq__(a, b): """a == b""" if type(b) is int: return a._numerator == b and a._denominator == 1 if isinstance(b, numbers.Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #14
Source File: fractions.py From Carnets with BSD 3-Clause "New" or "Revised" License | 6 votes |
def __eq__(a, b): """a == b""" if type(b) is int: return a._numerator == b and a._denominator == 1 if isinstance(b, numbers.Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #15
Source File: fractions.py From jawfish with MIT License | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, numbers.Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #16
Source File: fractions.py From ironpython3 with Apache License 2.0 | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, numbers.Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #17
Source File: fractions.py From Imogen with MIT License | 6 votes |
def __eq__(a, b): """a == b""" if type(b) is int: return a._numerator == b and a._denominator == 1 if isinstance(b, numbers.Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #18
Source File: validations.py From PyPCAPKit with BSD 3-Clause "New" or "Revised" License | 6 votes |
def complex_check(*args, stacklevel=2): """Check if arguments are *complex numbers* (``complex``). Args: *args: Arguments to check. stacklevel (int): Stack level to fetch originated function name. Raises: ComplexError: If any of the arguments is **NOT** *complex number* (``complex``). """ for var in args: if not isinstance(var, numbers.Complex): name = type(var).__name__ func = inspect.stack()[stacklevel][3] raise ComplexError(f'Function {func} expected complex number, {name} got instead.')
Example #19
Source File: fractions.py From Fluid-Designer with GNU General Public License v3.0 | 6 votes |
def __eq__(a, b): """a == b""" if type(b) is int: return a._numerator == b and a._denominator == 1 if isinstance(b, numbers.Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #20
Source File: compat.py From deep_image_model with Apache License 2.0 | 6 votes |
def as_str_any(value): """Converts to `str` as `str(value)`, but use `as_str` for `bytes`. Args: value: A object that can be converted to `str`. Returns: A `str` object. """ if isinstance(value, bytes): return as_str(value) else: return str(value) # Numpy 1.8 scalars don't inherit from numbers.Integral in Python 3, so we # need to check them specifically. The same goes from Real and Complex.
Example #21
Source File: fractions.py From datafari with Apache License 2.0 | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #22
Source File: __init__.py From tensorboard with Apache License 2.0 | 6 votes |
def path_to_str(path): """Returns the file system path representation of a `PathLike` object, else as it is. Args: path: An object that can be converted to path representation. Returns: A `str` object. """ if hasattr(path, "__fspath__"): path = as_str_any(path.__fspath__()) return path # Numpy 1.8 scalars don't inherit from numbers.Integral in Python 3, so we # need to check them specifically. The same goes from Real and Complex.
Example #23
Source File: fractions.py From Splunking-Crime with GNU Affero General Public License v3.0 | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #24
Source File: fractions.py From oss-ftp with MIT License | 6 votes |
def __eq__(a, b): """a == b""" if isinstance(b, Rational): return (a._numerator == b.numerator and a._denominator == b.denominator) if isinstance(b, numbers.Complex) and b.imag == 0: b = b.real if isinstance(b, float): if math.isnan(b) or math.isinf(b): # comparisons with an infinity or nan should behave in # the same way for any finite a, so treat a as zero. return 0.0 == b else: return a == a.from_float(b) else: # Since a doesn't know how to compare with b, let's give b # a chance to compare itself with a. return NotImplemented
Example #25
Source File: linear_combinations.py From Cirq with Apache License 2.0 | 5 votes |
def __imul__(self, other: PauliSumLike): if not isinstance(other, (numbers.Complex, PauliString, PauliSum)): return NotImplemented if isinstance(other, numbers.Complex): self._linear_dict *= other elif isinstance(other, PauliString): temp = PauliSum.from_pauli_strings([term * other for term in self]) self._linear_dict = temp._linear_dict elif isinstance(other, PauliSum): temp = PauliSum.from_pauli_strings( [term * other_term for term in self for other_term in other]) self._linear_dict = temp._linear_dict return self
Example #26
Source File: paulis.py From pyquil with Apache License 2.0 | 5 votes |
def is_zero(pauli_object: PauliDesignator) -> bool: """ Tests to see if a PauliTerm or PauliSum is zero. :param pauli_object: Either a PauliTerm or PauliSum :returns: True if PauliTerm is zero, False otherwise """ if isinstance(pauli_object, PauliTerm): assert isinstance(pauli_object.coefficient, Complex) return bool(np.isclose(pauli_object.coefficient, 0)) elif isinstance(pauli_object, PauliSum): assert isinstance(pauli_object.terms[0].coefficient, Complex) return len(pauli_object.terms) == 1 and np.isclose(pauli_object.terms[0].coefficient, 0) else: raise TypeError("is_zero only checks PauliTerms and PauliSum objects!")
Example #27
Source File: paulialgebra.py From quantumflow with Apache License 2.0 | 5 votes |
def __add__(self, other: Any) -> 'Pauli': if isinstance(other, Complex): other = Pauli.scalar(complex(other)) return pauli_sum(self, other)
Example #28
Source File: linear_combinations.py From Cirq with Apache License 2.0 | 5 votes |
def __rmul__(self, other: PauliSumLike): if isinstance(other, numbers.Complex): result = self.copy() result *= other return result elif isinstance(other, PauliString): result = self.copy() return PauliSum.from_pauli_strings([other]) * result return NotImplemented
Example #29
Source File: linear_combinations.py From Cirq with Apache License 2.0 | 5 votes |
def __sub__(self, other): if not isinstance(other, (numbers.Complex, PauliString, PauliSum)): return NotImplemented result = self.copy() result -= other return result
Example #30
Source File: linear_combinations.py From Cirq with Apache License 2.0 | 5 votes |
def __isub__(self, other): if isinstance(other, numbers.Complex): other = PauliSum.from_pauli_strings( [PauliString(coefficient=other)]) if isinstance(other, PauliString): other = PauliSum.from_pauli_strings([other]) if not isinstance(other, PauliSum): return NotImplemented self._linear_dict -= other._linear_dict return self