def _BinaryOperatorVariable(self, op, other, operatorClass=None, opShape=None, canInline=True, unit=None): """ :Parameters: - `op`: the operator function to apply (takes two arguments for `self` and `other`) - `other`: the quantity to be operated with - `operatorClass`: the `Variable` class that the binary operator should inherit from - `opShape`: the shape that should result from the operation """ if not isinstance(other, Variable): from fipy.variables.constant import _Constant other = _Constant(value=other) opShape, baseClass, other = self._shapeClassAndOther(opShape, operatorClass, other) if opShape is None or baseClass is None: return NotImplemented for v in [self, other]: if not v.getUnit().isDimensionless(): canInline = False # obtain a general operator class with the desired base class operatorClass = operatorClass or self._OperatorVariableClass(baseClass) from fipy.variables import binaryOperatorVariable binOp = binaryOperatorVariable._BinaryOperatorVariable(operatorClass) return binOp(op=op, var=[self, other], opShape=opShape, canInline=canInline, unit=unit, inlineComment=inline._operatorVariableComment(canInline=canInline))
def _UnaryOperatorVariable(self, op, operatorClass=None, opShape=None, canInline=True, unit=None): """ Check that getUnit() works for unOp >>> (-Variable(value="1 m")).getUnit() <PhysicalUnit m> """ operatorClass = operatorClass or self._OperatorVariableClass() from fipy.variables import unaryOperatorVariable unOp = unaryOperatorVariable._UnaryOperatorVariable(operatorClass) # If the caller has not specified a shape for the result, determine the # shape from the base class or from the inputs if opShape is None: opShape = self.shape if opShape is None: return NotImplemented if not self.getUnit().isDimensionless(): canInline = False return unOp(op=op, var=[self], opShape=opShape, canInline=canInline, unit=unit, inlineComment=inline._operatorVariableComment(canInline=canInline))