Variable#

Bases: Variable, Operable, Symbol

Represents a Variable symbol in GAMS.

Variables are the decision entities in a mathematical model. They can be free, positive, binary, integer, etc. See https://gamspy.readthedocs.io/en/latest/user/basics/variable.html

Parameters:

containerContainer: The Container object that this variable belongs to.
namestr, optional: Name of the variable. If not provided, a unique name is generated automatically.
typestr, optional: Type of the variable. Options: “free”, “positive”, “negative”, “binary”, “integer”, “sos1”, “sos2”, “semicont”, “semiint”. Default is “free”.
domainSequence[Set | Alias | str] | Set | Alias | Dim | str, optional: The domain of the variable. Can be a list of Sets/Aliases, a single Set/Alias, or strings representing set names. Use “*” for the universe set. Default is [] (scalar).
recordsAny, optional: Initial records (level/marginal/bounds) to populate the variable.
domain_forwardingbool | list[bool], optional: If True, adding records to this variable will implicitly add new elements to the domain sets (if they are dynamic). Default is False.
descriptionstr, optional: A human-readable description of the variable.
is_miro_outputbool, optional: If True, flags this variable as an output symbol for GAMS MIRO. Default is False.

Attributes:

container: Container of the symbol
default_records: Default records of a variable
description: Description of the symbol
dimension: The dimension of symbol
domain: List of domains given either as string (* for universe set) or as reference to the Set/Alias object
domain_forwarding: A boolean indicating whether domain forwarding is enabled
domain_labels: The column headings for the records DataFrame
domain_names: String version of domain names
domain_type: State of the domain links
fx: Fixed value of the variable.
is_scalar: Returns True if the len(self.domain) = 0
l: The Level of the variable (its current value).
lo: The Lower Bound of the variable.
m: The Marginal (dual value) of the variable.
modified: Flag that identifies if the symbol has been modified
name: Name of symbol
number_records: Number of records
prior: Branching Priority.
records: Returns the records (data) of the Variable as a DataFrame.
scale: The Scale factor of the variable.
shape: Returns a tuple describing the array dimensions if records were converted with .toDense()
stage: Branching Stage.
summary: Summary of the symbol
synchronize: Synchronization state of the symbol.
type: The type of variable; [binary, integer, positive, negative, free, sos1, sos2, semicont, semiintn]
up: The Upper Bound of the variable.

Methods

`computeInfeasibilities`()	Computes infeasibilities of the variable.
`countEps`([columns])	Counts total number of SpecialValues.EPS across columns
`countNA`([columns])	Counts total number of SpecialValues.NA across columns
`countNegInf`([columns])	Counts total number of SpecialValues.NegInf across columns
`countPosInf`([columns])	Counts total number of SpecialValues.PosInf across columns
`countUndef`([columns])	Counts total number of SpecialValues.Undef across columns
`dropDefaults`()	Drop records that are set to GAMS default records (check .default_records property for values)
`dropEps`()	Drop records from the symbol that are GAMS EPS (zero 0.0 records will be retained)
`dropMissing`()	Drop records from the symbol that are NaN (includes both NA and Undef special values)
`dropNA`()	Drop records from the symbol that are GAMS NA
`dropUndef`()	Drop records from the symbol that are GAMS Undef
`equals`(other[, columns, check_uels, ...])	Used to compare the symbol to another symbol
`findEps`([column])	Find positions of SpecialValues.EPS in value column
`findNA`([column])	Find positions of SpecialValues.NA in value column
`findNegInf`([column])	Find positions of SpecialValues.NegInf in value column
`findPosInf`([column])	Find positions of SpecialValues.PosInf in value column
`findSpecialValues`(values[, column])	Find positions of specified values in records columns
`findUndef`([column])	Find positions of SpecialValues.Undef in value column
`gamsRepr`()	Returns the string representation of this Variable in the GAMS language.
`generateRecords`([density, func, seed])	Convenience method to set standard pandas.DataFrame formatted records given domain set information.
`getAssignment`()	Returns the latest GAMS assignment statement for this Variable.
`getDeclaration`()	Returns the GAMS declaration statement for this Variable.
`getMaxAbsValue`([columns])	Get the maximum absolute value across chosen columns
`getMaxValue`([columns])	Get the maximum value across chosen columns
`getMeanValue`([columns])	Get the mean value across chosen columns
`getMinValue`([columns])	Get the minimum value across chosen columns
`getSparsity`()	Get the sparsity of the symbol w.r.t the cardinality
`getVariableListing`([n, filters])	Returns the variable listing (log output) from the last solve.
`isValid`([verbose, force])	Checks if the symbol is in a valid format
`pivot`([index, columns, value, fill_value])	Convenience function to pivot records into a new shape (only symbols with >1D can be pivoted)
`product`(*indices)	Equivalent to Product(indices, obj[obj.domain]).
`sand`(*indices)	Equivalent to Sand(indices, obj[obj.domain]).
`setRecords`(records[, uels_on_axes])	Sets the records (data) of the Variable.
`smax`(*indices)	Equivalent to Smax(indices, obj[obj.domain]).
`smin`(*indices)	Equivalent to Smin(indices, obj[obj.domain]).
`sor`(*indices)	Equivalent to Sor(indices, obj[obj.domain]).
`sum`(*indices)	Equivalent to Sum(indices, obj[obj.domain]).
`toDense`([column])	Convert column to a dense numpy.array format
`toDict`([columns, orient])	Convenience method to return symbol records as a Python dictionary
`toList`([columns])	Convenience method to return symbol records as a Python list
`toSparseCoo`([column])	Convert column to a sparse COOrdinate numpy.array format
`toValue`([column])	Convenience method to return symbol records as a Python float.
`whereMax`([column])	Find the domain entry of records with a maximum value (return first instance only)
`whereMaxAbs`([column])	Find the domain entry of records with a maximum absolute value (return first instance only)
`whereMin`([column])	Find the domain entry of records with a minimum value (return first instance only)

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i", records=['i1', 'i2'])
>>> v = gp.Variable(m, "v", domain=[i], type="positive", description="Production quantity")

computeInfeasibilities() → DataFrame[source]#

Computes infeasibilities of the variable.

Checks if the level value .l lies outside the bounds .lo and .up and returns a DataFrame containing the violations.

Returns:

pd.DataFrame: DataFrame showing the infeasible records.

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> x = gp.Variable(m, name="x")
>>> x.l[...] = -10
>>> x.lo[...] = 5
>>> x.computeInfeasibilities().values.tolist()
[[-10.0, 0.0, 5.0, inf, 1.0, 15.0]]

countEps(columns: str | List[str] | None = None) → int#

Counts total number of SpecialValues.EPS across columns

Parameters:

columnsstr | List[str], optional: Columns to count special values in, by default None

Returns:

Total number of SpecialValues.EPS across columns

countNA(columns: str | List[str] | None = None) → int#

Counts total number of SpecialValues.NA across columns

Parameters:

columnsstr | List[str], optional: Columns to count special values in, by default None

Returns:

Total number of SpecialValues.NA across columns

countNegInf(columns: str | List[str] | None = None) → int#

Counts total number of SpecialValues.NegInf across columns

Parameters:

columnsstr | List[str], optional: Columns to count special values in, by default None

Returns:

Total number of SpecialValues.NegInf across columns

countPosInf(columns: str | List[str] | None = None) → int#

Counts total number of SpecialValues.PosInf across columns

Parameters:

columnsstr | List[str], optional: Columns to count special values in, by default None

Returns:

Total number of SpecialValues.PosInf across columns

countUndef(columns: str | List[str] | None = None) → int#

Counts total number of SpecialValues.Undef across columns

Parameters:

columnsstr | List[str], optional: Columns to count special values in, by default None

Returns:

Total number of SpecialValues.Undef across columns

dropDefaults() → None#: Drop records that are set to GAMS default records (check .default_records property for values)

dropEps() → None#: Drop records from the symbol that are GAMS EPS (zero 0.0 records will be retained)

dropMissing() → None#: Drop records from the symbol that are NaN (includes both NA and Undef special values)

dropNA() → None#: Drop records from the symbol that are GAMS NA

dropUndef() → None#: Drop records from the symbol that are GAMS Undef

equals(other: Variable, columns: str = None, check_uels: bool = True, check_meta_data: bool = True, rtol: int | float | None = None, atol: int | float | None = None, verbose: bool = False) → bool#

Used to compare the symbol to another symbol

Parameters:

otherVariable: _description_
columnsstr, optional: allows the user to numerically compare only specified variable attributes, by default None; compare all
check_uelsbool, optional: If True, check both used and unused UELs and confirm same order, otherwise only check used UELs in data and do not check UEL order. by default True
check_meta_databool, optional: If True, check that symbol name and description are the same, otherwise skip. by default True
rtolint | float, optional: relative tolerance, by default None
atolint | float, optional: absolute tolerance, by default None
verbosebool, optional: If True, will return an exception from the asserter describing the nature of the difference. by default False

Returns:

bool: True if symbols are equal, False otherwise

findEps(column: str | None = None) → DataFrame#

Find positions of SpecialValues.EPS in value column

Parameters:

columnstr, optional: Column to find the special values in, by default None

Returns:

pd.DataFrame: Dataframe containing special values

findNA(column: str | None = None) → DataFrame#

Find positions of SpecialValues.NA in value column

Parameters:

columnstr, optional: Column to find the special values in, by default None

Returns:

pd.DataFrame: Dataframe containing special values

findNegInf(column: str | None = None) → DataFrame#

Find positions of SpecialValues.NegInf in value column

Parameters:

columnstr, optional: Column to find the special values in, by default None

Returns:

pd.DataFrame: Dataframe containing special values

findPosInf(column: str | None = None) → DataFrame#

Find positions of SpecialValues.PosInf in value column

Parameters:

columnstr, optional: Column to find the special values in, by default None

Returns:

pd.DataFrame: Dataframe containing special values

findSpecialValues(values: float | List[float], column: str | None = None) → DataFrame#

Find positions of specified values in records columns

Parameters:

valuesfloat | List[float]: Values to look for
columnstr, optional: Column to find the special values in, by default None

Returns:

pd.DataFrame: Dataframe containing special values

findUndef(column: str | None = None) → DataFrame#

Find positions of SpecialValues.Undef in value column

Parameters:

columnstr, optional: Column to find the special values in, by default None

Returns:

pd.DataFrame: Dataframe containing special values

gamsRepr() → str[source]#

Returns the string representation of this Variable in the GAMS language.

(e.g., ‘x(i)’).

Returns:

str: The GAMS string representation.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> x = gp.Variable(m, name="x", domain=i, type="positive")
>>> x.gamsRepr()
'x(i)'

Convenience method to set standard pandas.DataFrame formatted records given domain set information. Will generate records with the Cartesian product of all domain sets.

Parameters:

densityint | float | list, optional: Takes any value on the interval [0,1]. If density is <1 then randomly selected records will be removed. density will accept a list of length dimension – allows users to specify a density per symbol dimension, by default None
funcCallable, optional: Functions to generate the records, by default None; numpy.random.uniform(0,1)
seedint, optional: Random number state can be set with seed argument, by default None

getAssignment() → str[source]#

Returns the latest GAMS assignment statement for this Variable.

Returns:

str: The GAMS assignment string.

Raises:

ValidationError: If the variable has not been assigned.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i", records=['i1','i2'])
>>> v = gp.Variable(m, "v", domain=[i])
>>> v.l[i] = 0;
>>> v.getAssignment()
'v.l(i) = 0;'

getDeclaration() → str[source]#

Returns the GAMS declaration statement for this Variable.

(e.g., ‘Positive Variable x(i);’).

Returns:

str: The GAMS declaration string.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i", records=['i1','i2'])
>>> v = gp.Variable(m, "v", domain=[i])
>>> v.getDeclaration()
'free Variable v(i) / /;'

getMaxAbsValue(columns: str | List[str] | None = None) → float#

Get the maximum absolute value across chosen columns

Parameters:

columnsstr | List[str], optional: Columns to find maximum absolute values in, by default None

Returns:

float: Maximum absolute value

getMaxValue(columns: str | List[str] | None = None) → float#

Get the maximum value across chosen columns

Parameters:

columnsstr | List[str], optional: Columns to find maximum values in, by default None

Returns:

float: Maximum value

getMeanValue(columns: str | List[str] | None = None) → float#

Get the mean value across chosen columns

Parameters:

columnsstr | List[str], optional: Columns to find mean values in, by default None

Returns:

float: Mean value

getMinValue(columns: str | List[str] | None = None) → float#

Get the minimum value across chosen columns

Parameters:

columnsstr | List[str], optional: Columns to find minimum values in, by default None

Returns:

float: Minimum value

getSparsity() → float#

Get the sparsity of the symbol w.r.t the cardinality

Returns:

float: Sparsity of the symbol w.r.t the cardinality

getVariableListing(n: int | None = None, filters: list[list[str]] | None = None) → str[source]#

Returns the variable listing (log output) from the last solve.

This requires the model to have been solved with the variable_listing_limit option enabled.

Parameters:

nint, optional: Maximum number of variables to return.
filterslist[list[str]], optional: Filters to select specific elements for the listing. The list size must match the variable’s dimension.

Returns:

str: The text listing of the variable’s status and values.

Raises:

ValidationError: If the model was not solved with variable_listing_limit.
ValidationError: If the filter size does not match the variable dimension.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, records=["item1", "item2"])
>>> v = gp.Variable(m, domain=i)
>>> z = gp.Variable(m)
>>> e = gp.Equation(m, domain=i)
>>> e[i] = v[i] * z >= 5
>>> model = gp.Model(m, "test", equations=[e], problem="NLP", sense="MIN", objective=z)
>>> summary = model.solve(options=gp.Options(variable_listing_limit=10))
>>> print(v.getVariableListing())
v(item1)
                (.LO, .L, .UP, .M = -INF, 0, +INF, 0)
       (0)      e(item1)

v(item2)
                (.LO, .L, .UP, .M = -INF, 0, +INF, 0)
       (0)      e(item2)

isValid(verbose: bool = False, force: bool = False) → bool#

Checks if the symbol is in a valid format

Parameters:

verbosebool, optional: Throw exceptions if verbose=True, by default False
forcebool, optional: Recheck a symbol if force=True, by default False

Returns:

bool: True if a symbol is in valid format, False otherwise (throws exceptions if verbose=True)

Convenience function to pivot records into a new shape (only symbols with >1D can be pivoted)

Parameters:

indexstr | list, optional: If index is None then it is set to dimensions [0..dimension-1], by default None
columnsstr | list, optional: If columns is None then it is set to the last dimension, by default None
valuestr, optional: If value is None then the level values will be pivoted, by default None
fill_valueint | float | str, optional: Missing values in the pivot will take the value provided by fill_value, by default None

Returns:

DataFrame: Pivoted records dataframe

product(*indices: Set | Alias) → Product#

Equivalent to Product(indices, obj[obj.domain]). For example:

v = Variable(m, domain=[i, j, k]) v.product() is equivalent to Product((i,j), v[i, j, k]) v.product(i) is equivalent to Product(i, v[i, j, k]) v.product(i, j) is equivalent to Product((i, j), v[i, j, k])

Returns:

Product: Generated Product operation.

Raises:

ValidationError: In case the symbol is scalar.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i")
>>> j = gp.Set(m, "j")
>>> x = gp.Parameter(m, "x", domain=[i, j])
>>> y = gp.Parameter(m, "y")
>>> x.product().gamsRepr()
'prod((i,j),x(i,j))'
>>> gp.Product((i, j), x[i, j]).gamsRepr()
'prod((i,j),x(i,j))'

sand(*indices: Set | Alias) → Sand#

Equivalent to Sand(indices, obj[obj.domain]). For example:

v = Variable(m, domain=[i, j, k]) v.sand() is equivalent to Sand((i,j), v[i, j, k]) v.sand(i) is equivalent to Sand(i, v[i, j, k]) v.sand(i, j) is equivalent to Sand((i, j), v[i, j, k])

Returns:

Sand: Generated Sand operation.

Raises:

ValidationError: In case the symbol is scalar.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i")
>>> j = gp.Set(m, "j")
>>> x = gp.Parameter(m, "x", domain=[i, j])
>>> y = gp.Parameter(m, "y")
>>> x.sand().gamsRepr()
'sand((i,j),x(i,j))'
>>> gp.Sand((i, j), x[i, j]).gamsRepr()
'sand((i,j),x(i,j))'

setRecords(records: Any, uels_on_axes: bool = False) → None[source]#

Sets the records (data) of the Variable.

This is a convenience method to load data. It accepts various input formats. If uels_on_axes=True, it assumes domain information is in the pandas axes.

Parameters:

recordsAny: The data to load (e.g., list, numpy array, DataFrame).
uels_on_axesbool, optional: If True, assumes domain elements are in the axes of the DataFrame. Default is False.

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.setRecords(records=np.array([7, 18]))
>>> x.records.values.tolist()
[['seattle', 7.0, 0.0, -inf, inf, 1.0], ['san-diego', 18.0, 0.0, -inf, inf, 1.0]]

smax(*indices: Set | Alias) → Smax#

Equivalent to Smax(indices, obj[obj.domain]). For example:

v = Variable(m, domain=[i, j, k]) v.smax() is equivalent to Smax((i,j), v[i, j, k]) v.smax(i) is equivalent to Smax(i, v[i, j, k]) v.smax(i, j) is equivalent to Smax((i, j), v[i, j, k])

Returns:

Smax: Generated Smax operation.

Raises:

ValidationError: In case the symbol is scalar.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i")
>>> j = gp.Set(m, "j")
>>> x = gp.Parameter(m, "x", domain=[i, j])
>>> y = gp.Parameter(m, "y")
>>> x.smax().gamsRepr()
'smax((i,j),x(i,j))'
>>> gp.Smax((i, j), x[i, j]).gamsRepr()
'smax((i,j),x(i,j))'

smin(*indices: Set | Alias) → Smin#

Equivalent to Smin(indices, obj[obj.domain]). For example:

v = Variable(m, domain=[i, j, k]) v.smin() is equivalent to Smin((i,j), v[i, j, k]) v.smin(i) is equivalent to Smin(i, v[i, j, k]) v.smin(i, j) is equivalent to Smin((i, j), v[i, j, k])

Returns:

Smin: Generated Smin operation.

Raises:

ValidationError: In case the symbol is scalar.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i")
>>> j = gp.Set(m, "j")
>>> x = gp.Parameter(m, "x", domain=[i, j])
>>> y = gp.Parameter(m, "y")
>>> x.smin().gamsRepr()
'smin((i,j),x(i,j))'
>>> gp.Smin((i, j), x[i, j]).gamsRepr()
'smin((i,j),x(i,j))'

sor(*indices: Set | Alias) → Sor#

Equivalent to Sor(indices, obj[obj.domain]). For example:

v = Variable(m, domain=[i, j, k]) v.sor() is equivalent to Sor((i,j), v[i, j, k]) v.sor(i) is equivalent to Sor(i, v[i, j, k]) v.sor(i, j) is equivalent to Sor((i, j), v[i, j, k])

Returns:

Sor: Generated Sor operation.

Raises:

ValidationError: In case the symbol is scalar.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i")
>>> j = gp.Set(m, "j")
>>> x = gp.Parameter(m, "x", domain=[i, j])
>>> y = gp.Parameter(m, "y")
>>> x.sor().gamsRepr()
'sor((i,j),x(i,j))'
>>> gp.Sor((i, j), x[i, j]).gamsRepr()
'sor((i,j),x(i,j))'

sum(*indices: Set | Alias) → Sum#

Equivalent to Sum(indices, obj[obj.domain]). For example:

v = Variable(m, domain=[i, j, k]) v.sum() is equivalent to Sum((i,j), v[i, j, k]) v.sum(i) is equivalent to Sum(i, v[i, j, k]) v.sum(i, j) is equivalent to Sum((i, j), v[i, j, k])

Returns:

Sum: Generated Sum operation.

Raises:

ValidationError: In case the symbol is scalar.

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i")
>>> j = gp.Set(m, "j")
>>> x = gp.Parameter(m, "x", domain=[i, j])
>>> y = gp.Parameter(m, "y")
>>> x.sum().gamsRepr()
'sum((i,j),x(i,j))'
>>> gp.Sum((i, j), x[i, j]).gamsRepr()
'sum((i,j),x(i,j))'

toDense(column: str = 'level') → ndarray | None#

Convert column to a dense numpy.array format

Parameters:

columnstr, optional: The column to convert, by default “level”

Returns:

np.ndarray, optional: A column to a dense numpy.array format

toDict(columns: str | None = None, orient: str | None = None) → dict#

Convenience method to return symbol records as a Python dictionary

Parameters:

columnsstr, optional: Controls which attributes to include in the dict, by default None
orientstr, optional: Orient can take values natural or columns and will control the shape of the dict. Must use orient=”columns” if attempting to set symbol records with setRecords, by default None

Returns:

dict: Records as a Python dictionary

toList(columns: str | None = None) → list#

Convenience method to return symbol records as a Python list

Parameters:

columnsstr, optional: Controls which attributes to include in the list, by default None

Returns:

list: Records as a Python list

toSparseCoo(column: str = 'level') → coo_matrix | None#

Convert column to a sparse COOrdinate numpy.array format

Parameters:

columnstr, optional: The column to convert, by default “level”

Returns:

coo_matrix, optional: A column in coo_matrix format

toValue(column: str | None = None) → float#

Convenience method to return symbol records as a Python float. Only possible with scalar symbols

Parameters:

columnstr, optional: Attribute can be specified with column argument, by default None

Returns:

float: Value of the symbol

whereMax(column: str | None = None) → List[str]#

Find the domain entry of records with a maximum value (return first instance only)

Parameters:

columnstr, optional: Columns to find maximum values in, by default None

Returns:

List[str]: List of symbol names where maximum values exist

whereMaxAbs(column: str | None = None) → List[str]#

Find the domain entry of records with a maximum absolute value (return first instance only)

Parameters:

columnstr, optional: Columns to find maximum absolute values in, by default None

Returns:

List[str]: List of symbol names where maximum absolute values exist

whereMin(column: str | None = None) → List[str]#

Find the domain entry of records with a minimum value (return first instance only)

Parameters:

columnstr, optional: Columns to find minimum values in, by default None

Returns:

List[str]: List of symbol names where minimum values exist

property container#: Container of the symbol

property default_records#: Default records of a variable

property description#: Description of the symbol

property dimension#: The dimension of symbol

property domain#: List of domains given either as string (* for universe set) or as reference to the Set/Alias object

property domain_forwarding#: A boolean indicating whether domain forwarding is enabled

property domain_labels#: The column headings for the records DataFrame

property domain_names#: String version of domain names

property domain_type#: State of the domain links

property fx#

Fixed value of the variable.

Setting .fx implies setting both .lo and .up to the same value. Reading .fx returns the current fixed level (if fixed).

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.fx[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 7.0, 0.0, 7.0, 7.0, 1.0], ['san-diego', 18.0, 0.0, 18.0, 18.0, 1.0]]

property is_scalar: bool#

Returns True if the len(self.domain) = 0

Returns:

bool: True if the len(self.domain) = 0

property l#

The Level of the variable (its current value).

This corresponds to the .l suffix in GAMS. After a solve, this holds the solution value.

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.l[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 7.0, 0.0, -inf, inf, 1.0], ['san-diego', 18.0, 0.0, -inf, inf, 1.0]]

property lo#

The Lower Bound of the variable.

This corresponds to the .lo suffix in GAMS.

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.lo[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 0.0, 0.0, 7.0, inf, 1.0], ['san-diego', 0.0, 0.0, 18.0, inf, 1.0]]

property m#

The Marginal (dual value) of the variable.

This corresponds to the .m suffix in GAMS. Represents the reduced cost.

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.m[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 0.0, 7.0, -inf, inf, 1.0], ['san-diego', 0.0, 18.0, -inf, inf, 1.0]]

property modified#: Flag that identifies if the symbol has been modified

property name#: Name of symbol

property number_records#: Number of records

property prior#

Branching Priority.

This corresponds to the .prior suffix in GAMS. Allows identifying a priority for branching on discrete variables. Valid only for discrete variable types (integer, binary).

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i, type="integer")
>>> x.prior[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 0.0, 0.0, 0.0, inf, 7.0], ['san-diego', 0.0, 0.0, 0.0, inf, 18.0]]

property records#

Returns the records (data) of the Variable as a DataFrame.

The DataFrame contains columns for the domain sets, and columns for level, marginal, lower, upper, and scale.

Returns:

DataFrame

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.fx[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 7.0, 0.0, 7.0, 7.0, 1.0], ['san-diego', 18.0, 0.0, 18.0, 18.0, 1.0]]

property scale#

The Scale factor of the variable.

This corresponds to the .scale suffix in GAMS, used for scaling the variable to improve numerical stability.

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.scale[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 0.0, 0.0, -inf, inf, 7.0], ['san-diego', 0.0, 0.0, -inf, inf, 18.0]]

property shape: tuple#

Returns a tuple describing the array dimensions if records were converted with .toDense()

Returns:

tuple: A tuple describing the records dimensions

property stage#

Branching Stage.

This corresponds to the .stage suffix in GAMS. Used in stochastic programming or advanced branching strategies.

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i, type="integer")
>>> x.stage[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 0.0, 0.0, 0.0, inf, 7.0], ['san-diego', 0.0, 0.0, 0.0, inf, 18.0]]

property summary#: Summary of the symbol

property synchronize: bool#

Synchronization state of the symbol. If True, the symbol data will be communicated with GAMS. Otherwise, GAMS state will not be updated.

Returns:

bool

Examples

>>> import gamspy as gp
>>> m = gp.Container()
>>> i = gp.Set(m, "i", records=["i1"])
>>> i.synchronize = False
>>> i["i2"] = True
>>> i.records.uni.tolist()
['i1']
>>> i.synchronize = True
>>> i.records.uni.tolist()
['i1', 'i2']

property type#

The type of variable; [binary, integer, positive, negative, free, sos1, sos2, semicont, semiintn]

Returns:

str: The type of variable

property up#

The Upper Bound of the variable.

This corresponds to the .up suffix in GAMS.

Returns:

ImplicitParameter

Examples

>>> import gamspy as gp
>>> import numpy as np
>>> m = gp.Container()
>>> i = gp.Set(m, name="i", records=["seattle", "san-diego"])
>>> d = gp.Parameter(m, name="d", domain=i, records=np.array([7, 18]))
>>> x = gp.Variable(m, name="x", domain=i)
>>> x.up[i] = d[i]
>>> x.records.values.tolist()
[['seattle', 0.0, 0.0, -inf, 7.0, 1.0], ['san-diego', 0.0, 0.0, -inf, 18.0, 1.0]]

class gamspy.VariableType(*values)[source]#

Bases: Enum

Enumeration of available variable types.

BINARY = 'binary'#: Discrete variable that can only take values of 0 or 1.

FREE = 'free'#: No bounds on variable. Both bounds may be changed from the default values by the user.

INTEGER = 'integer'#: Discrete variable that can only take integer values between the bounds.

NEGATIVE = 'negative'#: No positive values are allowed for variables. The user may change both bounds from the default value.

POSITIVE = 'positive'#: No negative values are allowed for variable. The user may change both bounds from the default value.

SEMICONT = 'semicont'#: Semi-continuous, must be zero or above a given minimum level.

SEMIINT = 'semiint'#: Semi-integer, must be zero or above a given minimum level and integer.

SOS1 = 'sos1'#: A set of variables, such that at most one variable within a group may have a non-zero value.

SOS2 = 'sos2'#: A set of variables, such that at most two variables within a group may have non-zero values and the two non-zero values are adjacent.