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
