def __idiv__(self, value):
"""Divide value by scalar or element-by-element"""
if isinstance(value, ndarray):
NDMath.divide_elements(self.nda, value.nda)
else:
NDMath.divide_elements(self.nda, value)
return self
def __iadd__(self, value):
"""Add scalar to all elements, or add other array element-by-element"""
if isinstance(value, ndarray):
NDMath.increment(self.nda, value.nda)
else:
NDMath.increment(self.nda, value)
return self
def __imul__(self, value):
"""Scale value by scalar or element-by-element"""
if isinstance(value, ndarray):
NDMath.scale(self.nda, value.nda)
else:
NDMath.scale(self.nda, value)
return self
def __idiv__(self, value):
"""Divide value by scalar or element-by-element"""
if isinstance(value, ndarray):
NDMath.divide_elements(self.nda, value.nda)
else:
NDMath.divide_elements(self.nda, value)
return self
def __imul__(self, value):
"""Scale value by scalar or element-by-element"""
if isinstance(value, ndarray):
NDMath.scale(self.nda, value.nda)
else:
NDMath.scale(self.nda, value)
return self
def __iadd__(self, value):
"""Add scalar to all elements, or add other array element-by-element"""
if isinstance(value, ndarray):
NDMath.increment(self.nda, value.nda)
else:
NDMath.increment(self.nda, value)
return self
def __sub__(self, value):
"""Subtract scalar from all elements, or sub. other array element-by-element"""
if isinstance(value, ndarray):
return ndarray(NDMath.subtract(self.nda, value.nda))
else:
result = self.nda.clone()
NDMath.increment(result, -value)
return ndarray(result)
def __sub__(self, value):
"""Subtract scalar from all elements, or sub. other array element-by-element"""
if isinstance(value, ndarray):
return ndarray(NDMath.subtract(self.nda, value.nda))
else:
result = self.nda.clone()
NDMath.increment(result, -value)
return ndarray(result)
def __add__(self, value):
"""Add scalar to all elements, or add other array element-by-element"""
if isinstance(value, ndarray):
return ndarray(NDMath.add(self.nda, value.nda))
else:
result = self.nda.clone()
NDMath.increment(result, value)
return ndarray(result)
def __add__(self, value):
"""Add scalar to all elements, or add other array element-by-element"""
if isinstance(value, ndarray):
return ndarray(NDMath.add(self.nda, value.nda))
else:
result = self.nda.clone()
NDMath.increment(result, value)
return ndarray(result)
def sqrt(value):
"""Determine square root of elements"""
if not isinstance(value, ndarray):
if value < 0:
return nan
return math.sqrt(value)
return ndarray(NDMath.sqrt(value.nda))
def sqrt(value):
"""Determine square root of elements"""
if not isinstance(value, ndarray):
if value < 0:
return nan
return math.sqrt(value)
return ndarray(NDMath.sqrt(value.nda))
def __rsub__(self, value):
"""Subtract scalar from all elements, or sub. other array element-by-element"""
result = self.nda.clone()
NDMath.negative(result)
NDMath.increment(result, value)
return ndarray(result)
def __mul__(self, value):
"""Multiply by scalar or by other array elements"""
if not isinstance(value, ndarray):
value = array([ value ])
return ndarray(NDMath.multiply(self.nda, value.nda))
def __rdiv__(self, value):
"""Divide by scalar or by other array elements"""
if not isinstance(value, ndarray):
value = array([value])
return ndarray(NDMath.divide(value.nda, self.nda))
def __rsub__(self, value):
"""Subtract scalar from all elements, or sub. other array element-by-element"""
result = self.nda.clone()
NDMath.negative(result)
NDMath.increment(result, value)
return ndarray(result)
def __mul__(self, value):
"""Multiply by scalar or by other array elements"""
if not isinstance(value, ndarray):
value = array([value])
return ndarray(NDMath.multiply(self.nda, value.nda))
def max(self):
"""Returns maximum array element"""
return NDMath.max(self.nda)
def __rdiv__(self, value):
"""Divide by scalar or by other array elements"""
if not isinstance(value, ndarray):
value = array([ value ])
return ndarray(NDMath.divide(value.nda, self.nda))
def __neg__(self):
"""Return array where sign of each element has been reversed"""
result = self.nda.clone()
NDMath.negative(result)
return ndarray(result)
def __abs__(self):
"""Element-wise absolute values"""
return ndarray(NDMath.abs(self.nda))
def exp(value):
"""Determine square root of elements"""
if not isinstance(value, ndarray):
return math.exp(value)
return ndarray(NDMath.exp(value.nda))
def __neg__(self):
"""Return array where sign of each element has been reversed"""
result = self.nda.clone()
NDMath.negative(result)
return ndarray(result)
def abs(value):
"""Determine absolute value of elements"""
if not isinstance(value, ndarray):
return math.fabs(value)
return ndarray(NDMath.abs(value.nda))
def max(self):
"""Returns maximum array element"""
return NDMath.max(self.nda)
def min(self):
"""Returns minimum array element"""
return NDMath.min(self.nda)
def __rpow__(self, value):
"""Raise array elements to power specified by value"""
if not isinstance(value, ndarray):
value = array([value])
return ndarray(NDMath.power(value.nda, self.nda))
def __rpow__(self, value):
"""Raise array elements to power specified by value"""
if not isinstance(value, ndarray):
value = array([ value ])
return ndarray(NDMath.power(value.nda, self.nda))
def sum(self):
"""Returns sum over all array elements"""
return NDMath.sum(self.nda)
def sum(self):
"""Returns sum over all array elements"""
return NDMath.sum(self.nda)
def min(self):
"""Returns minimum array element"""
return NDMath.min(self.nda)
def exp(value):
"""Determine square root of elements"""
if not isinstance(value, ndarray):
return math.exp(value)
return ndarray(NDMath.exp(value.nda))
def log10(value):
"""Determine log of elements (base 10)"""
if not isinstance(value, ndarray):
return math.log10(value)
return ndarray(NDMath.log10(value.nda))
def __abs__(self):
"""Element-wise absolute values"""
return ndarray(NDMath.abs(self.nda))
def log10(value):
"""Determine log of elements (base 10)"""
if not isinstance(value, ndarray):
return math.log10(value)
return ndarray(NDMath.log10(value.nda))
def abs(value):
"""Determine absolute value of elements"""
if not isinstance(value, ndarray):
return math.fabs(value)
return ndarray(NDMath.abs(value.nda))
