def __init__(self, index, integrand, domain, *, condition=None, conditions=None): r''' Integrates integrand over indices over domain. Arguments serve analogous roles to Forall arguments (found in basiclogic/booleans): index: single instance var integrand: instanceExpressions domains: conditions (except no longer optional) ''' OperationOverInstances.__init__(self, Integrate._operator_, index, integrand, domain=domain, condition=condition, conditions=conditions) if len(self.instanceVars) != 1: raise ValueError('Only one index allowed per integral!') elif isinstance(self.domain, Interval): raise ValueError('Can\'t integrate over DiscreteContiguousSet!') elif self.domain == Reals: self.domain = IntervalCC(Neg(infinity), infinity) self.index = self.instanceVars[0] self.integrand = self.instanceExpr
def __init__(self, indices, summand, domain, conditions=tuple()): r''' Sum summand over indices over domains. Arguments serve analogous roles to Forall arguments (found in basiclogic/booleans): indices: instance vars summand: instanceExpressions domains: conditions (except no longer optional) ''' OperationOverInstances.__init__(self, Sum._operator_, indices, summand, domain=domain, conditions=conditions) if len(self.instanceVars) != 1: raise ValueError('Only one index allowed per integral!') self.indices = self.instanceVars self.summand = self.instanceExpr self.index = self.instanceVars[0] if isinstance(self.domain, RealInterval): raise ValueError( 'Sum cannot sum over non-discrete set (e.g. Interval)') elif self.domain == Reals: raise ValueError('Sum cannot sum over Reals.') elif self.domain == Integers: self.domain = Interval(Neg(infinity), infinity) elif self.domain == Naturals: self.domain = Interval(zero, infinity)
def __init__(self, instanceVarOrVars, instanceElement, domain=None, domains=None, conditions=tuple()): ''' Create an expression representing the set of all instanceElement for instanceVar(s) such that the conditions are satisfied: {instanceElement | conditions}_{instanceVar(s) \in S} ''' # nestMultiIvars=False will ensure it does NOT treat multiple instance variables as # nested SetOfAll operations -- that would not make sense. # (unlike forall, exists, summation, and product where it does make sense). OperationOverInstances.__init__(self, SetOfAll._operator_, instanceVarOrVars, instanceElement, domain=domain, conditions=conditions, nestMultiIvars=False) self.instanceElement = self.instanceExpr if hasattr(self, 'instanceVar'): if not hasattr(self, 'domain'): raise ValueError("SetOfAll requires a domain") elif hasattr(self, 'instanceVars'): if not hasattr(self, 'domains') or None in self.domains: raise ValueError("SetOfAll requires a domain(s)") else: assert False, "Expecting either 'instanceVar' or 'instanceVars' to be set"
def __init__(self, instanceVar, instanceElement, domain, conditions=tuple()): ''' Create an expression representing the set of all instanceElement for instanceVars such that the conditions are satisfied: {instanceElement | conditions}_{instanceVar \in S} ''' OperationOverInstances.__init__(self, SetOfAll._operator_, instanceVar, instanceElement, domain=domain, conditions=conditions) self.instanceElement = self.instanceExpr
def __init__(self, instance_param_or_params, instance_element, domain=None, *, domains=None, condition=None, conditions=None, _lambda_map=None): ''' Create an expression representing the set of all instance_element for instance parameter(s) such that the conditions are satisfied: {instance_element | conditions}_{instance_param_or_params \in S} ''' OperationOverInstances.__init__(self, SetOfAll._operator_, instance_param_or_params, instance_element, domain=domain, domains=domains, condition=condition, conditions=conditions, _lambda_map=_lambda_map) self.instance_element = self.instance_expr if hasattr(self, 'instance_param'): if not hasattr(self, 'domain'): raise ValueError("SetOfAll requires a domain") elif hasattr(self, 'instance_params'): if not hasattr(self, 'domains') or None in self.domains: raise ValueError("SetOfAll requires domains") else: assert False, ( "Expecting either 'instance_param' or 'instance_params' " "to be set")
def __init__(self, instanceParamOrParams, instanceExpr, *, domain=None, domains=None, condition=None, conditions=None, _lambda_map=None): ''' Create a Forall expression: forall_{instanceParamOrParams | conditions} instanceExpr. This expresses that the instanceExpr is true for all values of the instance parameter(s) given that the optional condition(s) is/are satisfied. The instance parameter(s) and condition(s) may be singular or plural (iterable). ''' OperationOverInstances.__init__(self, Forall._operator_, instanceParamOrParams, instanceExpr, domain=domain, domains=domains, condition=condition, conditions=conditions, _lambda_map=_lambda_map)
def __init__(self, instanceParamOrParams, instanceExpr, *, domain=None, domains=None, condition=None, conditions=None, _lambda_map=None): ''' Create a exists (there exists) expression: exists_{instanceParamOrParams | conditions} instanceExpr This expresses that there exists a value of the instance parameters(s) for which the optional condition(s) is/are satisfied and the instanceExpr is true. The instance parameters(s) and condition(s) may be singular or plural (iterable). ''' OperationOverInstances.__init__(self, NotExists._operator_, instanceParamOrParams, instanceExpr, domain=domain, domains=domains, condition=condition, conditions=conditions, _lambda_map=_lambda_map)
def __init__(self, indexOrIndices, summand, *, domain=None, domains=None, condition=None, conditions=None, _lambda_map=None): r''' Sum summand over indices over domains. Arguments serve analogous roles to Forall arguments (found in basiclogic/booleans): indices: instance vars summand: instanceExpressions domains: conditions (except no longer optional) ''' OperationOverInstances.__init__(self, Sum._operator_, indexOrIndices, summand, domain=domain, domains=domains, condition=condition, conditions=conditions, _lambda_map=_lambda_map) if hasattr(self, 'instanceVar'): self.index = self.instanceVar if hasattr(self, 'instanceVars'): self.indices = self.instanceVars self.summand = self.instanceExpr """
def __init__(self, indexOrIndices, summand, domain=None, domains=None, conditions=tuple(), _lambda_map=None): r''' Sum summand over indices over domains. Arguments serve analogous roles to Forall arguments (found in basiclogic/booleans): indices: instance vars summand: instanceExpressions domains: conditions (except no longer optional) ''' # nestMultiIvars=True will cause it to treat multiple instance variables as nested Sum operations internally # and only join them together as a style consequence. OperationOverInstances.__init__(self, Sum._operator_, indexOrIndices, summand, domain=domain, domains=domains, conditions=conditions, nestMultiIvars=True, _lambda_map=_lambda_map) if hasattr(self, 'instanceVar'): self.index = self.instanceVar if hasattr(self, 'instanceVars'): self.indices = self.instanceVars self.summand = self.instanceExpr """
def __init__(self, instanceVarOrVars, instanceExpr, domain=None, domains=None, conditions=tuple(), _lambda_map=None): ''' Create a exists (there exists) expression: exists_{instanceVars | conditions} instanceExpr This expresses that there exists a value of the instanceVar(s) for which the optional condition(s) is/are satisfied and the instanceExpr is true. The instanceVar(s) and condition(s) may be singular or plural (iterable). ''' # nestMultiIvars=True will cause it to treat multiple instance # variables as nested NotExists operations internally # and only join them together as a style consequence. OperationOverInstances.__init__(self, NotExists._operator_, instanceVarOrVars, instanceExpr, domain, domains, conditions, nestMultiIvars=True, _lambda_map=_lambda_map)
def __init__(self, instanceVarOrVars, instanceExpr, domain=None, domains=None, conditions = tuple()): ''' Create a Forall expression: forall_{instanceVars | conditions} instanceExpr. This expresses that the instanceExpr is true for all values of the instanceVar(s) given that the optional condition(s) is/are satisfied. The instanceVar(s) and condition(s) may be singular or plural (iterable). ''' OperationOverInstances.__init__(self, Forall._operator_, instanceVarOrVars, instanceExpr, domain, domains, conditions)
def __init__(self, indices, summand, domain, conditions=tuple()): r''' Sum summand over indices over domains. Arguments serve analogous roles to Forall arguments (found in basiclogic/booleans): indices: instance vars summand: instanceExpressions domains: conditions (except no longer optional) ''' OperationOverInstances.__init__(self, Prod._operator_, indices, summand, domain=domain, conditions=conditions)
def __init__(self, instanceVarOrVars, instanceExpr, domain=None, domains=None, conditions = tuple(), _lambda_map=None): ''' Create a Forall expression: forall_{instanceVars | conditions} instanceExpr. This expresses that the instanceExpr is true for all values of the instanceVar(s) given that the optional condition(s) is/are satisfied. The instanceVar(s) and condition(s) may be singular or plural (iterable). ''' # nestMultiIvars=True will cause it to treat multiple instance # variables as nested Forall operations internally # and only join them together as a style consequence. OperationOverInstances.__init__(self, Forall._operator_, instanceVarOrVars, instanceExpr, domain, domains, conditions, nestMultiIvars=True, _lambda_map=_lambda_map)
def __init__(self, instanceVarOrVars, instanceExpr, domain=None, domains=None, conditions=tuple()): ''' Create a exists (there exists) expression: exists_{instanceVars | condition} instanceExpr This expresses that there exists a value of the instanceVar(s) for which the optional condition(s) is/are satisfied and the instanceExpr is true. The instanceVar(s) and condition(s) may be singular or plural (iterable). ''' OperationOverInstances.__init__(self, Exists._operator_, instanceVarOrVars, instanceExpr, domain, domains, conditions)
def __init__(self, indices, summand, domain, conditions=tuple()): r''' Sum summand over indices over domains. Arguments serve analogous roles to Forall arguments (found in basiclogic/booleans): indices: instance vars summand: instanceExpressions domains: conditions (except no longer optional) ''' # nestMultiIvars=True will cause it to treat multiple instance variables as nested Prod operations internally # and only join them together as a style consequence. OperationOverInstances.__init__(self, Prod._operator_, indices, summand, domain=domain, conditions=conditions, nestMultiIvars=True)
def __init__(self, index_or_indices, summand, *, domain=None, domains=None, condition=None, conditions=None, styles=None, _lambda_map=None): r''' Sum summand over indices over domains. Arguments serve analogous roles to Forall arguments (found in basiclogic.booleanss): indices: instance vars summand: instance_expressions domains: conditions (except no longer optional) ''' if (domains is not None): raise NotImplementedError("Sum class not yet implemented for " "multiple domains nor for multiple " "indices.") OperationOverInstances.__init__(self, Sum._operator_, index_or_indices, summand, domain=domain, domains=domains, condition=condition, conditions=conditions, styles=styles, _lambda_map=_lambda_map) if hasattr(self, 'instance_param'): self.index = self.instance_param if hasattr(self, 'instance_params'): self.indices = self.instance_params self.summand = self.instance_expr """
def __init__(self, index_or_indices, integrand, *, domain=None, domains=None, condition=None, conditions=None, styles=None, _lambda_map=None): r''' Represents a definite integral of the integrand over the index_or_indices over the domain, with arguments serving roles analogous to those for Forall arguments (found in logic.booleans.quantification.universality) and Sum arguments (found in numbers.summation): index_or_indices: a single instance var such as x integrand : instance expression domain : conditions Despite the generality preserved for the arguments, such Integrate objects are currently defined only for a single index and over a single continuous interval domain defined by a numerical set (such as Real, RealPos, etc.) or real interval (using IntervalCC, IntervalCO, IntervalOC, or IntervalOO objects). ''' # original # OperationOverInstances.__init__( # self, Integrate._operator_, index, integrand, # domain=domain, condition=condition, conditions=conditions, # styles=styles) # new 20220111 # If domain expressed as a special number set, # re-express domain as a continuous interval before # feeding as argument to OperationOverInstances.__init__(). # if domain == Real: # domain = IntervalOO(Neg(infinity), infinity) # elif domain == RealPos: # domain = IntervalOO(zero, infinity) # elif domain == RealNonNeg: # domain = IntervalCO(zero, infinity) # elif domain == RealNeg: # domain = IntervalOO(Neg(infinity), zero) # elif domain == RealNonPos: # domain = IntervalOC(Neg(infinity), zero) OperationOverInstances.__init__( self, Integrate._operator_, index_or_indices, integrand, domain=domain, domains=domains, condition=condition, conditions=conditions, styles=styles, _lambda_map=_lambda_map) # original # if len(self.instance_vars) != 1: # raise ValueError('Only one index allowed per integral!') # elif isinstance(self.domain, Interval): # raise ValueError('Can\'t integrate over DiscreteContiguousSet!') # elif self.domain == Real: # self.domain = IntervalCC(Neg(infinity), infinity) # self.index = self.instance_vars[0] # self.integrand = self.instance_expr # new if hasattr(self, 'instance_param'): self.index = self.instance_param if hasattr(self, 'instance_params'): self.indices = self.instance_params if len(self.instance_params.entries) != 1: raise ValueError('Only one index allowed per integral!') if isinstance(self.domain, Interval): # elaborate this error message later raise ValueError('Can\'t integrate over DiscreteContiguousSet!') self.integrand = self.instance_expr