def __init__(self, *args, **kwd):
self._rule = kwd.pop('rule', None)
kwd['ctype'] = BuildCheck
IndexedComponent.__init__(self, *args, **kwd)
#
if not type(self._rule) is types.FunctionType:
raise ValueError("BuildCheck must have an 'rule' option specified whose value is a function")
def __init__(self, *args, **kwd):
self._rule = kwd.pop('rule', None)
self._initialize = kwd.pop('initialize', {})
self._implicit = kwd.pop('implicit', {})
self._extends = kwd.pop('extends', None)
kwd.setdefault('ctype', Port)
IndexedComponent.__init__(self, *args, **kwd)
def __init__(self, *args, **kwd):
self._rule = kwd.pop('rule', None)
kwd['ctype'] = BuildCheck
IndexedComponent.__init__(self, *args, **kwd)
#
if not type(self._rule) is types.FunctionType:
raise ValueError("BuildCheck must have an 'rule' option specified whose value is a function")
def __init__(self, *args, **kwd):
kwd.setdefault('ctype', Connector)
self._rule = kwd.pop('rule', None)
self._initialize = kwd.pop('initialize', {})
self._implicit = kwd.pop('implicit', {})
self._extends = kwd.pop('extends', None)
IndexedComponent.__init__(self, *args, **kwd)
self._conval = {}
def __init__(self, *args, **kwd):
kwd.setdefault('ctype', Connector)
self._rule = kwd.pop('rule', None)
self._initialize = kwd.pop('initialize', None)
self._implicit = kwd.pop('implicit', None)
self._extends = kwd.pop('extends', None)
IndexedComponent.__init__(self, *args, **kwd)
self._conval = {}
def __init__(self, *args, **kwd):
uncset = kwd.pop('uncset', None)
self._uncset = uncset
bounds = kwd.pop('bounds', None)
self._bounds_init_value = None
if type(bounds) is tuple:
self._bounds_init_value = bounds
elif bounds is not None:
raise ValueError("Keyword 'bounds' has to be a tuple")
kwd.setdefault('ctype', UncParam)
IndexedComponent.__init__(self, *args, **kwd)
def __init__(self, *args, **kwd):
#
# Default keyword values
#
initialize = kwd.pop('initialize', None)
initialize = kwd.pop('rule', initialize)
domain = kwd.pop('within', Reals)
domain = kwd.pop('domain', domain)
bounds = kwd.pop('bounds', None)
self._dense = kwd.pop('dense', True)
self._units = kwd.pop('units', None)
if self._units is not None:
self._units = units.get_units(self._units)
#
# Initialize the base class
#
kwd.setdefault('ctype', Var)
IndexedComponent.__init__(self, *args, **kwd)
#
# Determine if the domain argument is a functor or other object
#
self._domain_init_value = None
self._domain_init_rule = None
if is_functor(domain):
self._domain_init_rule = domain
else:
self._domain_init_value = domain
#
# Allow for functions or functors for value initialization,
# without confusing with Params, etc (which have a __call__ method).
#
self._value_init_value = None
self._value_init_rule = None
if is_functor(initialize) and (not isinstance(initialize,
NumericValue)):
self._value_init_rule = initialize
else:
self._value_init_value = initialize
#
# Determine if the bound argument is a functor or other object
#
self._bounds_init_rule = None
self._bounds_init_value = None
if is_functor(bounds):
self._bounds_init_rule = bounds
elif type(bounds) is tuple:
self._bounds_init_value = bounds
elif bounds is not None:
raise ValueError(
"Variable 'bounds' keyword must be a tuple or function")
def __init__(self, *args, **kwds):
_init = self._pop_from_kwargs(
'Expression', kwds, ('rule', 'expr', 'initialize'), None)
# Historically, Expression objects were dense (but None):
# setting arg_not_specified causes Initializer to recognize
# _init==None as a constant initializer returning None
#
# To initialize a completely empty Expression, pass either
# initialize={} (to require explicit setitem before a getitem),
# or initialize=NOTSET (to allow getitem before setitem)
self._rule = Initializer(_init, arg_not_specified=NOTSET)
kwds.setdefault('ctype', Expression)
IndexedComponent.__init__(self, *args, **kwds)
def __init__(self, *args, **kwds):
self._init_rule = kwds.pop('rule', None)
self._init_expr = kwds.pop('initialize', None)
self._init_expr = kwds.pop('expr', self._init_expr)
if is_functor(self._init_expr) and \
(not isinstance(self._init_expr, NumericValue)):
raise TypeError("A callable type that is not a Pyomo "
"expression can not be used to initialize "
"an Expression object. Use 'rule' to initalize "
"with function types.")
if (self._init_rule is not None) and \
(self._init_expr is not None):
raise ValueError("Both a rule and an expression can not be "
"used to initialized an Expression object")
kwds.setdefault('ctype', Expression)
IndexedComponent.__init__(self, *args, **kwds)
def __init__(self, *args, **kwd):
#
# Default keyword values
#
initialize = kwd.pop('initialize', None )
initialize = kwd.pop('rule', initialize )
domain = kwd.pop('within', Reals )
domain = kwd.pop('domain', domain )
bounds = kwd.pop('bounds', None )
self._dense = kwd.pop('dense', True )
#
# Initialize the base class
#
kwd.setdefault('ctype', Var)
IndexedComponent.__init__(self, *args, **kwd)
#
# Determine if the domain argument is a functor or other object
#
self._domain_init_value = None
self._domain_init_rule = None
if is_functor(domain):
self._domain_init_rule = domain
else:
self._domain_init_value = domain
#
# Allow for functions or functors for value initialization,
# without confusing with Params, etc (which have a __call__ method).
#
self._value_init_value = None
self._value_init_rule = None
if is_functor(initialize) and (not isinstance(initialize,NumericValue)):
self._value_init_rule = initialize
else:
self._value_init_value = initialize
#
# Determine if the bound argument is a functor or other object
#
self._bounds_init_rule = None
self._bounds_init_value = None
if is_functor(bounds):
self._bounds_init_rule = bounds
elif type(bounds) is tuple:
self._bounds_init_value = bounds
elif bounds is not None:
raise ValueError("Variable 'bounds' keyword must be a tuple or function")
def __init__(self, *args, **kwds):
_init = tuple(arg
for arg in (kwds.pop(_arg, None)
for _arg in ('rule', 'expr', 'initialize'))
if arg is not None)
if len(_init) == 1:
_init = _init[0]
elif not _init:
_init = None
else:
raise ValueError(
"Duplicate initialization: Expression() only "
"accepts one of 'rule=', 'expr=', and 'initialize='")
kwds.setdefault('ctype', Expression)
IndexedComponent.__init__(self, *args, **kwds)
self.rule = Initializer(_init)
def __init__(self, *args, **kwd):
self._rule = kwd.pop('rule', None )
self._rule = kwd.pop('initialize', self._rule )
self._validate = kwd.pop('validate', None )
self.domain = kwd.pop('domain', Any )
self.domain = kwd.pop('within', self.domain )
self._mutable = kwd.pop('mutable', Param.DefaultMutable )
self._default_val = kwd.pop('default', None )
self._dense_initialize = kwd.pop('initialize_as_dense', False)
#
if 'repn' in kwd:
logger.error(
"The 'repn' keyword is not a validate keyword argument for Param")
#
if self.domain is None:
self.domain = Any
#
kwd.setdefault('ctype', Param)
IndexedComponent.__init__(self, *args, **kwd)
def __init__(self, *args, **kwd):
initialize = kwd.pop('initialize', None)
initialize = kwd.pop('rule', initialize)
self._dense = kwd.pop('dense', True)
kwd.setdefault('ctype', BooleanVar)
IndexedComponent.__init__(self, *args, **kwd)
# Allow for functions or functors for value initialization,
# without confusing with Params, etc (which have a __call__ method).
#
self._value_init_value = None
self._value_init_rule = None
if is_functor(initialize) and (not isinstance(initialize, BooleanValue)):
self._value_init_rule = initialize
else:
self._value_init_value = initialize
def __init__(self, *args, **kwd):
self._rule = kwd.pop('rule', _NotValid )
self._rule = kwd.pop('initialize', self._rule )
self._validate = kwd.pop('validate', None )
self.domain = kwd.pop('domain', Any )
self.domain = kwd.pop('within', self.domain )
self._mutable = kwd.pop('mutable', Param.DefaultMutable )
self._default_val = kwd.pop('default', _NotValid )
self._dense_initialize = kwd.pop('initialize_as_dense', False)
#
if 'repn' in kwd:
logger.error(
"The 'repn' keyword is not a validate keyword argument for Param")
#
if self.domain is None:
self.domain = Any
#
kwd.setdefault('ctype', Param)
IndexedComponent.__init__(self, *args, **kwd)
def __init__(self, *args, **kwds):
self._init_rule = kwds.pop('rule', None)
self._init_expr = kwds.pop('initialize', None)
self._init_expr = kwds.pop('expr', self._init_expr)
if is_functor(self._init_expr) and \
(not isinstance(self._init_expr, NumericValue)):
raise TypeError(
"A callable type that is not a Pyomo "
"expression can not be used to initialize "
"an Expression object. Use 'rule' to initalize "
"with function types.")
if (self._init_rule is not None) and \
(self._init_expr is not None):
raise ValueError(
"Both a rule and an expression can not be "
"used to initialized an Expression object")
kwds.setdefault('ctype', Expression)
IndexedComponent.__init__(self, *args, **kwds)
def __init__(self, *args, **kwds):
_init = tuple(arg
for arg in (kwds.pop(_arg, None)
for _arg in ('rule', 'expr', 'initialize'))
if arg is not None)
if len(_init) == 1:
_init = _init[0]
elif not _init:
_init = None
else:
raise ValueError(
"Duplicate initialization: Expression() only "
"accepts one of 'rule=', 'expr=', and 'initialize='")
kwds.setdefault('ctype', Expression)
IndexedComponent.__init__(self, *args, **kwds)
# Historically, Expression objects were dense (but None):
# setting arg_not_specified causes Initializer to recognize
# _init==None as a constant initializer returning None
self._rule = Initializer(_init, arg_not_specified=NOTSET)
def __init__(self, *args, **kwd):
_init = self._pop_from_kwargs('Param', kwd, ('rule', 'initialize'),
NOTSET)
self._rule = Initializer(_init,
treat_sequences_as_mappings=False,
arg_not_specified=NOTSET)
self.domain = self._pop_from_kwargs('Param', kwd, ('domain', 'within'))
if self.domain is None:
self.domain = _ImplicitAny(owner=self, name='Any')
self._validate = kwd.pop('validate', None)
self._mutable = kwd.pop('mutable', Param.DefaultMutable)
self._default_val = kwd.pop('default', Param.NoValue)
self._dense_initialize = kwd.pop('initialize_as_dense', False)
self._units = kwd.pop('units', None)
if self._units is not None:
self._units = units.get_units(self._units)
self._mutable = True
kwd.setdefault('ctype', Param)
IndexedComponent.__init__(self, *args, **kwd)
def __init__(self, *args, **kwargs):
#
# Default keyword values
#
self._rule_init = Initializer(self._pop_from_kwargs(
'Var', kwargs, ('rule', 'initialize'), None))
self._rule_domain = SetInitializer(self._pop_from_kwargs(
'Var', kwargs, ('domain', 'within'), Reals))
_bounds_arg = kwargs.pop('bounds', None)
self._dense = kwargs.pop('dense', True)
self._units = kwargs.pop('units', None)
if self._units is not None:
self._units = units.get_units(self._units)
#
# Initialize the base class
#
kwargs.setdefault('ctype', Var)
IndexedComponent.__init__(self, *args, **kwargs)
#
# Now that we can call is_indexed(), process bounds initializer
#
if self.is_indexed():
treat_bounds_sequences_as_mappings = not (
isinstance(_bounds_arg, Sequence)
and len(_bounds_arg) == 2
and not isinstance(_bounds_arg[0], Sequence)
)
else:
treat_bounds_sequences_as_mappings = False
if not self._dense:
logger.warning(
"ScalarVar object '%s': dense=False is not allowed "
"for scalar variables; converting to dense=True"
% (self.name,))
self._dense = True
self._rule_bounds = Initializer(
_bounds_arg,
treat_sequences_as_mappings=treat_bounds_sequences_as_mappings
)
def __init__(self, *args, **kwd):
self._rule = kwd.pop('rule', Param.NoValue )
self._rule = kwd.pop('initialize', self._rule )
self._validate = kwd.pop('validate', None )
self.domain = kwd.pop('domain', None )
self.domain = kwd.pop('within', self.domain )
self._mutable = kwd.pop('mutable', Param.DefaultMutable )
self._default_val = kwd.pop('default', Param.NoValue )
self._dense_initialize = kwd.pop('initialize_as_dense', False)
self._units = kwd.pop('units', None)
if self._units is not None:
self._units = units.get_units(self._units)
self._mutable = True
#
if 'repn' in kwd:
logger.error(
"The 'repn' keyword is not a validate keyword argument for Param")
#
if self.domain is None:
self.domain = _ImplicitAny(owner=self, name='Any')
#
kwd.setdefault('ctype', Param)
IndexedComponent.__init__(self, *args, **kwd)
def __init__(self, *args, **kwd):
uncset = kwd.pop('uncset', None)
self._uncset = uncset
kwd.setdefault('ctype', UncParam)
IndexedComponent.__init__(self, *args, **kwd)