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): 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)