Справка по API

# JuMP.JuMP — Module

JuMP

Язык алгебраического моделирования для Julia.

Дополнительные сведения см. на сайте https://jump.dev.

# JuMP.ALMOST_DUAL_INFEASIBLE — Constant

ALMOST_DUAL_INFEASIBLE::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

ALMOST_DUAL_INFEASIBLE: алгоритм заключил, что для задачи не существует двойного ограничения в пределах нестрогих допусков.

# JuMP.ALMOST_INFEASIBLE — Constant

ALMOST_INFEASIBLE::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

ALMOST_INFEASIBLE: алгоритм заключил, что в пределах нестрогих допусков не существует допустимого решения.

# JuMP.ALMOST_LOCALLY_SOLVED — Constant

ALMOST_LOCALLY_SOLVED::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

ALMOST_LOCALLY_SOLVED: алгоритм сошелся к стационарной точке, локальному оптимальному решению, либо ему не удалось найти направления для улучшения в пределах нестрогих допусков.

# JuMP.ALMOST_OPTIMAL — Constant

ALMOST_OPTIMAL::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

ALMOST_OPTIMAL: алгоритм нашел глобальное оптимальное решение в нестрогих допусках.

# JuMP.AUTOMATIC — Constant

В поле moi_backend содержится CachingOptimizer в режиме AUTOMATIC.

# JuMP.DIRECT — Constant

В поле moi_backend содержится AbstractOptimizer. Дополнительная копия модели не сохраняется. moi_backend должен поддерживать add_constraint и т. д.

# JuMP.DUAL_INFEASIBLE — Constant

DUAL_INFEASIBLE::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

DUAL_INFEASIBLE: алгоритм заключил, что для задачи не существует двойного ограничения. Если, помимо этого, известно о существовании допустимого (прямого) решения, этот статус обычно свидетельствует о том, что задача является неограниченной с некоторыми техническими исключениями.

# JuMP.FEASIBILITY_SENSE — Constant

FEASIBILITY_SENSE::OptimizationSense

Экземпляр перечисления OptimizationSense.

FEASIBILITY_SENSE: у модели нет целевой функции.

# JuMP.FEASIBLE_POINT — Constant

FEASIBLE_POINT::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

FEASIBLE_POINT: итоговый вектор представляет собой допустимую точку.

# JuMP.INFEASIBILITY_CERTIFICATE — Constant

INFEASIBILITY_CERTIFICATE::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

INFEASIBILITY_CERTIFICATE: итоговый вектор представляет собой свидетельство о недопустимости. Если PrimalStatus имеет значение INFEASIBILITY_CERTIFICATE, прямой итоговый вектор представляет собой свидетельство о двойственной недопустимости. Если DualStatus имеет значение INFEASIBILITY_CERTIFICATE, двойственный итоговый вектор представляет собой доказательство прямой недопустимости.

# JuMP.INFEASIBLE — Constant

INFEASIBLE::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

INFEASIBLE: алгоритм заключил, что не существует допустимого решения.

# JuMP.INFEASIBLE_OR_UNBOUNDED — Constant

INFEASIBLE_OR_UNBOUNDED::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

INFEASIBLE_OR_UNBOUNDED: алгоритм остановил выполнение, поскольку решил, что задача неразрешима или неограниченна; это иногда случается во время предварительного решения MIP.

# JuMP.INFEASIBLE_POINT — Constant

INFEASIBLE_POINT::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

INFEASIBLE_POINT: итоговый вектор представляет собой недопустимую точку.

# JuMP.INTERRUPTED — Constant

INTERRUPTED::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

INTERRUPTED: алгоритм остановил выполнение из-за сигнала прерывания.

# JuMP.INVALID_MODEL — Constant

INVALID_MODEL::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

INVALID_MODEL: алгоритм остановил выполнение из-за недопустимости модели.

# JuMP.INVALID_OPTION — Constant

INVALID_OPTION::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

INVALID_OPTION: алгоритм остановил выполнение, так как ему был предоставлен недопустимый параметр.

# JuMP.ITERATION_LIMIT — Constant

ITERATION_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

ITERATION_LIMIT: итеративный алгоритм остановился после выполнения максимального количества итераций.

# JuMP.LOCALLY_INFEASIBLE — Constant

LOCALLY_INFEASIBLE::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

LOCALLY_INFEASIBLE: алгоритм сошелся к недопустимой точке или иным образом завершил поиск, не найдя допустимого решения, но без гарантий того, что допустимого решения не существует.

# JuMP.LOCALLY_SOLVED — Constant

LOCALLY_SOLVED::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

LOCALLY_SOLVED: алгоритм сошелся к стационарной точке, локальному оптимальному решению, не нашел направления для улучшения или иным образом завершил поиск без гарантий глобального решения.

# JuMP.MANUAL — Constant

В поле moi_backend содержится CachingOptimizer в режиме MANUAL.

# JuMP.MAX_SENSE — Constant

MAX_SENSE::OptimizationSense

Экземпляр перечисления OptimizationSense.

MAX_SENSE: цель состоит в том, чтобы максимизировать целевую функцию.

# JuMP.MEMORY_LIMIT — Constant

MEMORY_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

MEMORY_LIMIT: алгоритм остановил выполнение, так как закончилась память.

# JuMP.MIN_SENSE — Constant

MIN_SENSE::OptimizationSense

Экземпляр перечисления OptimizationSense.

MIN_SENSE: цель состоит в том, чтобы минимизировать целевую функцию.

# JuMP.NEARLY_FEASIBLE_POINT — Constant

NEARLY_FEASIBLE_POINT::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

NEARLY_FEASIBLE_POINT: итоговый вектор является допустимым, если некоторые допуски ограничений нестрогие.

# JuMP.NEARLY_INFEASIBILITY_CERTIFICATE — Constant

NEARLY_INFEASIBILITY_CERTIFICATE::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

NEARLY_INFEASIBILITY_CERTIFICATE: результат отвечает нестрогому критерию свидетельства о недопустимости.

# JuMP.NEARLY_REDUCTION_CERTIFICATE — Constant

NEARLY_REDUCTION_CERTIFICATE::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

NEARLY_REDUCTION_CERTIFICATE: результат отвечает нестрогому критерию свидетельства о некорректности.

# JuMP.NODE_LIMIT — Constant

NODE_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

NODE_LIMIT: алгоритм ветвей и границ остановил выполнение, так как исследовал максимальное количество узлов в дереве ветвей и границ.

# JuMP.NORM_LIMIT — Constant

NORM_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

NORM_LIMIT: алгоритм остановил выполнение, так как норма итерации стала слишком большой.

# JuMP.NO_SOLUTION — Constant

NO_SOLUTION::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

NO_SOLUTION: итоговый вектор пустой.

# JuMP.NUMERICAL_ERROR — Constant

NUMERICAL_ERROR::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

NUMERICAL_ERROR: алгоритм остановил выполнение, так как произошла неустранимая численная ошибка.

# JuMP.OBJECTIVE_LIMIT — Constant

OBJECTIVE_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

OBJECTIVE_LIMIT: алгоритм остановил выполнение, так как нашел решение лучше минимального предела, установленного пользователем.

# JuMP.OPTIMAL — Constant

OPTIMAL::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

OPTIMAL: алгоритм нашел глобальное оптимальное решение.

# JuMP.OPTIMIZE_NOT_CALLED — Constant

OPTIMIZE_NOT_CALLED::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

OPTIMIZE_NOT_CALLED: алгоритм не был запущен.

# JuMP.OTHER_ERROR — Constant

OTHER_ERROR::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

OTHER_ERROR: алгоритм остановил выполнение из-за ошибки, не описываемой одним из перечисленных выше статусов.

# JuMP.OTHER_LIMIT — Constant

OTHER_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

OTHER_LIMIT: алгоритм остановил выполнение из-за предела, не описываемого одним из перечисленных выше статусов LIMIT.

# JuMP.OTHER_RESULT_STATUS — Constant

OTHER_RESULT_STATUS::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

OTHER_RESULT_STATUS: итоговый вектор содержит решение с интерпретацией, не охватываемой ни одним из определенных выше статусов.

# JuMP.REDUCTION_CERTIFICATE — Constant

REDUCTION_CERTIFICATE::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

REDUCTION_CERTIFICATE: итоговый вектор представляет собой свидетельство о некорректности. Подробные сведения см. в этой статье. Если PrimalStatus имеет значение REDUCTION_CERTIFICATE, прямой итоговый вектор представляет собой доказательство некорректной постановки двойственной задачи. Если DualStatus имеет значение REDUCTION_CERTIFICATE, двойственный итоговый вектор представляет собой доказательство некорректной постановки прямой задачи.

# JuMP.SLOW_PROGRESS — Constant

SLOW_PROGRESS::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

SLOW_PROGRESS: алгоритм остановил выполнение, так как не смог продолжить продвижение к решению.

# JuMP.SOLUTION_LIMIT — Constant

SOLUTION_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

SOLUTION_LIMIT: алгоритм остановил выполнение, так как нашел необходимое количество решений. Часто используется в MIP, чтобы решатель возвращал первое найденное допустимое решение.

# JuMP.TIME_LIMIT — Constant

TIME_LIMIT::TerminationStatusCode

Экземпляр перечисления TerminationStatusCode.

TIME_LIMIT: алгоритм остановил выполнение по истечении указанного пользователем времени вычисления.

# JuMP.UNKNOWN_RESULT_STATUS — Constant

UNKNOWN_RESULT_STATUS::ResultStatusCode

Экземпляр перечисления ResultStatusCode.

UNKNOWN_RESULT_STATUS: итоговый вектор содержит решение с неизвестной интерпретацией.

# JuMP._CONSTRAINT_LIMIT_FOR_PRINTING — _Constant

const _CONSTRAINT_LIMIT_FOR_PRINTING = Ref{Int}(100)

Глобальная константа, используемая для управления тем, когда при выводе модели пропускаются ограничения.

Значение возвращается и задается с помощью _CONSTRAINT_LIMIT_FOR_PRINTING[].

julia> _CONSTRAINT_LIMIT_FOR_PRINTING[]
100

julia> _CONSTRAINT_LIMIT_FOR_PRINTING[] = 10
10

# JuMP._TERM_LIMIT_FOR_PRINTING — _Constant

const _TERM_LIMIT_FOR_PRINTING = Ref{Int}(60)

Глобальная константа, используемая для управления тем, когда при выводе выражений пропускаются члены.

Значение возвращается и задается с помощью _TERM_LIMIT_FOR_PRINTING[].

julia> _TERM_LIMIT_FOR_PRINTING[]
60

julia> _TERM_LIMIT_FOR_PRINTING[] = 10
10

# JuMP.op_and — Constant

op_and(x, y)

Функция, по умолчанию равная x & y, но при вызове с переменными или выражениями JuMP возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_and(true, false)
false

julia> op_and(true, x)
true && x

# JuMP.op_equal_to — Constant

op_equal_to(x, y)

Функция, по умолчанию равная x == y, но при вызове с переменными или выражениями JuMP возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_equal_to(2, 2)
true

julia> op_equal_to(x, 2)
x == 2

# JuMP.op_greater_than_or_equal_to — Constant

op_greater_than_or_equal_to(x, y)

Функция, по умолчанию равная x >= y, но при вызове с переменными или выражениями JuMP возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_greater_than_or_equal_to(2, 2)
true

julia> op_greater_than_or_equal_to(x, 2)
x >= 2

# JuMP.op_less_than_or_equal_to — Constant

op_less_than_or_equal_to(x, y)

Функция, по умолчанию равная x <= y, но при вызове с переменными или выражениями JuMP возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_less_than_or_equal_to(2, 2)
true

julia> op_less_than_or_equal_to(x, 2)
x <= 2

# JuMP.op_or — Constant

op_or(x, y)

Функция, по умолчанию равная x | y, но при вызове с переменными или выражениями JuMP возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_or(true, false)
true

julia> op_or(true, x)
true || x

# JuMP.op_strictly_greater_than — Constant

op_strictly_greater_than(x, y)

Функция, по умолчанию равная x > y, но при вызове с переменными или выражениями JuMP возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_strictly_greater_than(1, 2)
false

julia> op_strictly_greater_than(x, 2)
x > 2

# JuMP.op_strictly_less_than — Constant

op_strictly_less_than(x, y)

Функция, по умолчанию равная x < y, но при вызове с переменными или выражениями JuMP возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_strictly_less_than(1, 2)
true

julia> op_strictly_less_than(x, 2)
x < 2

# JuMP.AbstractConstraint — Type

abstract type AbstractConstraint

Абстрактный базовый тип для всех типов ограничений. В объектах AbstractConstraint непосредственно хранятся функция и множество, в отличие от объектов ConstraintRef, которые являются просто ссылками на ограничения, хранящиеся в модели. Объекты AbstractConstraint не нужно прикреплять к модели.

# JuMP.AbstractJuMPScalar — Type

AbstractJuMPScalar <: MutableArithmetics.AbstractMutable

Абстрактный базовый тип для всех скалярных типов.

Создание подтипов AbstractMutable позволит перенаправлять вызовы некоторых функций Base в метод в MA, который более корректно обрабатывает продвижение типов (например, продвижение в произведениях разреженных матриц в SparseArrays обычно не работает для типов JuMP) и использует изменчивость AffExpr и QuadExpr.

# JuMP.AbstractModel — Type

AbstractModel

Абстрактный тип, подтипы которого должны создаваться при создании расширений JuMP.

# JuMP.AbstractScalarSet — Type

AbstractScalarSet

Абстрактный тип для определения новых скалярных множеств в JuMP.

Реализуйте moi_set(::AbstractScalarSet) для преобразования типа во множество MOI.

См. также описание метода moi_set.

# JuMP.AbstractShape — Type

AbstractShape

Абстрактная векторизуемая форма. Для плоской векторной формы объекта, имеющего форму shape, исходный объект можно получить с помощью reshape_vector.

# JuMP.AbstractVariable — Type

AbstractVariable

Переменная, возвращаемая build_variable. Представляет переменную, которая еще не была добавлена ни в одну модель. В указанную модель model ее можно добавить с помощью add_variable.

# JuMP.AbstractVariableRef — Type

AbstractVariableRef

Переменная, возвращаемая add_variable. При аффинных (или квадратичных) операциях с переменными типа V<:AbstractVariableRef и коэффициентами типа T создается GenericAffExpr{T,V} (или соответственно GenericQuadExpr{T,V}).

# JuMP.AbstractVectorSet — Type

AbstractVectorSet

Абстрактный тип для определения новых множеств в JuMP.

Реализуйте moi_set(::AbstractVectorSet, dim::Int) для преобразования типа во множество MOI.

См. также описание метода moi_set.

# JuMP.AffExpr — Type

AffExpr

Псевдоним для GenericAffExpr{Float64,VariableRef}, варианта типа GenericAffExpr, используемого в JuMP.

# JuMP.ArrayShape — Type

ArrayShape{N}(dims::NTuple{N,Int}) where {N}

An AbstractShape that represents array-valued constraints.

Example

julia> model = Model();

julia> @variable(model, x[1:2, 1:3]);

julia> c = @constraint(model, x >= 0, Nonnegatives())
[x[1,1]  x[1,2]  x[1,3]
 x[2,1]  x[2,2]  x[2,3]] ∈ Nonnegatives()

julia> shape(constraint_object(c))
ArrayShape{2}((2, 3))

# JuMP.BridgeableConstraint — Type

BridgeableConstraint(
    constraint::C,
    bridge_type::B;
    coefficient_type::Type{T} = Float64,
) where {C<:AbstractConstraint,B<:Type{<:MOI.Bridges.AbstractBridge},T}

Объект AbstractConstraint, представляющий ограничение constraint, которое можно соединить мостом типа bridge_type{coefficient_type}.

Добавление BridgeableConstraint в модель равносильно следующему:

add_bridge(model, bridge_type; coefficient_type = coefficient_type)
add_constraint(model, constraint)

Пример

Для нового типа скалярного множества CustomSet с мостом CustomBridge, который может соединять ограничения «F в CustomSet», когда пользователь выполняет следующий код:

model = Model()
@variable(model, x)
@constraint(model, x + 1 in CustomSet())
optimize!(model)

с оптимизатором, который не поддерживает ограничения «F в CustomSet», ограничение не будет соединено, если сначала не будет вызван метод add_bridge(model, CustomBridge).

Чтобы автоматически добавлять CustomBridge к любой модели, к которой добавлено ограничение «F в CustomSet», добавьте следующий метод:

function JuMP.build_constraint(
    error_fn::Function,
    func::AbstractJuMPScalar,
    set::CustomSet,
)
    constraint = ScalarConstraint(func, set)
    return BridgeableConstraint(constraint, CustomBridge)
end

Примечание

Расширения JuMP должны расширять JuMP.build_constraint только в том случае, если они также определяют CustomSet, по трем причинам:

Если несколько расширений перегружают один и тот же метод JuMP, возникают проблемы.
При отсутствии метода пользователи не будут информироваться о том, что они забыли загрузить

модуль расширения, в котором определен метод build_constraint.

Определение метода, в котором ни функция, ни какой-либо из типов аргументов

не определены в пакете, называется «пиратством типов» и не приветствуется в руководстве по стилю Julia.

# JuMP.ComplexPlane — Type

ComplexPlane

Объект комплексной плоскости, который можно использовать для создания комплексной переменной в макросе @variable.

Пример

Рассмотрим следующий пример.

julia> model = Model();

julia> @variable(model, x in ComplexPlane())
real(x) + imag(x) im

julia> all_variables(model)
2-element Vector{VariableRef}:
 real(x)
 imag(x)

В выходных данных последней команды мы видим, что были созданы две вещественные переменные. Переменная Julia x связывается с аффинным выражением посредством этих двух переменных, которые параметризуют комплексную плоскость.

# JuMP.ComplexVariable — Type

ComplexVariable{S,T,U,V} <: AbstractVariable

Структура, используемая при добавлении комплексных переменных.

См. также описание типа ComplexPlane.

# JuMP.ConstraintNotOwned — Type

struct ConstraintNotOwned{C<:ConstraintRef} <: Exception
    constraint_ref::C
end

Ошибка, возникающая при использовании ограничения constraint_ref в модели, отличной от owner_model(constraint_ref).

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, x >= 0)
c : x ≥ 0

julia> model_new = Model();

julia> MOI.get(model_new, MOI.ConstraintName(), c)
ERROR: ConstraintNotOwned{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, ScalarShape}}(c : x ≥ 0)
Stacktrace:
[...]

# JuMP.ConstraintRef — Type

ConstraintRef

Содержит ссылку на модель и соответствующий MOI.ConstraintIndex.

# JuMP.GenericAffExpr — Type

mutable struct GenericAffExpr{CoefType,VarType} <: AbstractJuMPScalar
    constant::CoefType
    terms::OrderedDict{VarType,CoefType}
end

Тип выражения, представляющий аффинное выражение следующего вида: .

Поля

.constant: ограничение c в выражении.
.terms: словарь OrderedDict с ключами типа VarType и значениями типа CoefType, описывающий разреженный вектор a.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> expr = x[2] + 3.0 * x[1] + 4.0
x[2] + 3 x[1] + 4

julia> expr.constant
4.0

julia> expr.terms
OrderedCollections.OrderedDict{VariableRef, Float64} with 2 entries:
  x[2] => 1.0
  x[1] => 3.0

# JuMP.GenericAffExpr — Method

GenericAffExpr(constant::V, kv::Vararg{Pair{K,V},N}) where {K,V,N}

Создает GenericAffExpr, передавая константу и пары дополнительных аргументов.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> GenericAffExpr(1.0, x => 1.0)
x + 1

# JuMP.GenericAffExpr — Method

GenericAffExpr(constant::V, kv::AbstractArray{Pair{K,V}}) where {K,V}

Создает GenericAffExpr, передавая константу и вектор пар.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> GenericAffExpr(1.0, [x => 1.0])
x + 1

# JuMP.GenericModel — Method

GenericModel{T}(
    [optimizer_factory;]
    add_bridges::Bool = true,
) where {T<:Real}

Создает экземпляр модели JuMP.

Если указан аргумент optimizer_factory, модель инициализируется с оптимизатором, возвращаемым MOI.instantiate(optimizer_factory).

Если аргумент optimizer_factory не указан, используйте set_optimizer, чтобы задать оптимизатор, перед вызовом optimize!.

Если add_bridges, JuMP добавляет MOI.Bridges.LazyBridgeOptimizer, чтобы автоматически переформулировать задачу в форму, поддерживаемую оптимизатором.

Тип значения T

Передача типа, отличного от Float64, в качестве типа значения T является более сложной операцией. Тип значения должен соответствовать тому, который ожидается выбранным оптимизатором. Подробные сведения см. в документации по оптимизаторам.

Если в документации не указано иное, предполагается, что оптимизатор поддерживает только Float64.

При выборе неподдерживаемого типа значения возникает ошибка MOI.UnsupportedConstraint или MOI.UnsupportedAttribute, причем момент ее возникновения (во время построения модели или во время вызова optimize!) зависит от того, как решатель взаимодействует с JuMP.

Пример

julia> model = GenericModel{BigFloat}();

julia> typeof(model)
GenericModel{BigFloat}

# JuMP.GenericNonlinearExpr — Type

GenericNonlinearExpr{V}(head::Symbol, args::Vector{Any})
GenericNonlinearExpr{V}(head::Symbol, args::Any...)

Нелинейная функция head(args...) со скалярным значением, представленная в виде символьного дерева выражения, с оператором вызова head и упорядоченными аргументами в args.

V — это тип AbstractVariableRef, присутствующий в выражении и используемый для диспетчеризации расширений JuMP.

head

Оператор head::Symbol должен поддерживаться моделью.

Список поддерживаемых одномерных операторов по умолчанию содержится в следующей константе:

MOI.Nonlinear.DEFAULT_UNIVARIATE_OPERATORS

Список поддерживаемых многомерных операторов по умолчанию содержится в следующей константе:

MOI.Nonlinear.DEFAULT_MULTIVARIATE_OPERATORS

Дополнительные операторы можно добавить с помощью макроса @operator.

Чтобы просмотреть полный список операторов, поддерживаемых MOI.ModelLike, запросите атрибут MOI.ListOfSupportedNonlinearOperators.

args

Вектор args содержит аргументы нелинейной функции. Если оператор одномерный, он должен содержать один элемент. В противном случае он может содержать несколько элементов.

При заданном подтипе V типа AbstractVariableRef для GenericNonlinearExpr{V} каждый элемент должен быть одного из следующих типов:

константное значение типа <:Real;
V;
GenericAffExpr{T,V};
GenericQuadExpr{T,V};
GenericNonlinearExpr{V};

где T<:Real и T == value_type(V).

Неподдерживаемые операторы

Если оптимизатор не поддерживает head, выдается ошибка MOI.UnsupportedNonlinearOperator.

Возникать эта ошибка может в разные моменты: при первом добавлении функции в модель или при вызове optimize!.

Пример

Для представления функции выполните следующий код:

julia> model = Model();

julia> @variable(model, x)
x

julia> f = sin(x)^2
sin(x) ^ 2.0

julia> f = GenericNonlinearExpr{VariableRef}(
           :^,
           GenericNonlinearExpr{VariableRef}(:sin, x),
           2.0,
       )
sin(x) ^ 2.0

# JuMP.GenericQuadExpr — Type

mutable struct GenericQuadExpr{CoefType,VarType} <: AbstractJuMPScalar
    aff::GenericAffExpr{CoefType,VarType}
    terms::OrderedDict{UnorderedPair{VarType}, CoefType}
end

Тип выражения, представляющий квадратичное выражение следующего вида: .

Поля

.aff: объект GenericAffExpr, представляющий аффинную часть выражения.
.terms: словарь OrderedDict с ключами типа UnorderedPair{VarType} и значениями типа CoefType, описывающий разреженный список членов q.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> expr = 2.0 * x[1]^2 + x[1] * x[2] + 3.0 * x[1] + 4.0
2 x[1]² + x[1]*x[2] + 3 x[1] + 4

julia> expr.aff
3 x[1] + 4

julia> expr.terms
OrderedCollections.OrderedDict{UnorderedPair{VariableRef}, Float64} with 2 entries:
  UnorderedPair{VariableRef}(x[1], x[1]) => 2.0
  UnorderedPair{VariableRef}(x[1], x[2]) => 1.0

# JuMP.GenericQuadExpr — Method

GenericQuadExpr(
    aff::GenericAffExpr{V,K},
    kv::AbstractArray{Pair{UnorderedPair{K},V}}
) where {K,V}

Создает GenericQuadExpr, передавая GenericAffExpr и вектор пар (UnorderedPair, коэффициент).

Пример

julia> model = Model();

julia> @variable(model, x);

julia> GenericQuadExpr(GenericAffExpr(1.0, x => 2.0), [UnorderedPair(x, x) => 3.0])
3 x² + 2 x + 1

# JuMP.GenericReferenceMap — Type

GenericReferenceMap{T}

Сопоставление между переменной и ссылкой на ограничение модели и ее копии. Ссылку на скопированную модель можно получить, обратившись по индексу к сопоставлению с соответствующей ссылкой на исходную модель.

# JuMP.GenericVariableRef — Type

GenericVariableRef{T} <: AbstractVariableRef

Содержит ссылку на модель и соответствующий MOI.VariableIndex.

# JuMP.GenericVariableRef — Method

GenericVariableRef{T}(c::ConstraintRef)

Возвращает переменную, связанную с ConstraintRef, если c является ограничением для одной переменной.

Пример

julia> model = Model();

julia> @variable(model, x >= 0)
x

julia> c = LowerBoundRef(x)
x ≥ 0

julia> VariableRef(c) == x
true

# JuMP.GreaterThanZero — Type

GreaterThanZero()

A struct used to intercept when >= or ≥ is used in a macro via operator_to_set.

This struct is not the same as Nonnegatives so that we can disambiguate x >= y and x - y in Nonnegatives().

This struct is not intended for general usage, but it may be useful to some JuMP extensions.

Example

julia> operator_to_set(error, Val(:>=))
GreaterThanZero()

# JuMP.HermitianMatrixAdjointShape — Type

HermitianMatrixAdjointShape(side_dimension)

The dual_shape of HermitianMatrixShape.

This shape is not intended for regular use.

# JuMP.HermitianMatrixShape — Type

HermitianMatrixShape

Объект формы для эрмитовой квадратной матрицы из side_dimension строк и столбцов. Векторизованная форма соответствует MOI.HermitianPositiveSemidefiniteConeTriangle.

# JuMP.HermitianMatrixSpace — Type

HermitianMatrixSpace()

Используется в макросе @variable, ограничивая матрицу переменных эрмитовой формой.

Пример

julia> model = Model();

julia> @variable(model, Q[1:2, 1:2] in HermitianMatrixSpace())
2×2 LinearAlgebra.Hermitian{GenericAffExpr{ComplexF64, VariableRef}, Matrix{GenericAffExpr{ComplexF64, VariableRef}}}:
 real(Q[1,1])                    real(Q[1,2]) + imag(Q[1,2]) im
 real(Q[1,2]) - imag(Q[1,2]) im  real(Q[2,2])

# JuMP.HermitianPSDCone — Type

HermitianPSDCone

Объект эрмитова положительно полуопределенного конуса, который можно использовать для создания эрмитовой положительно полуопределенной квадратной матрицы в макросах @variable и @constraint.

Пример

Рассмотрим следующий пример.

julia> model = Model();

julia> @variable(model, H[1:3, 1:3] in HermitianPSDCone())
3×3 LinearAlgebra.Hermitian{GenericAffExpr{ComplexF64, VariableRef}, Matrix{GenericAffExpr{ComplexF64, VariableRef}}}:
 real(H[1,1])                    …  real(H[1,3]) + imag(H[1,3]) im
 real(H[1,2]) - imag(H[1,2]) im     real(H[2,3]) + imag(H[2,3]) im
 real(H[1,3]) - imag(H[1,3]) im     real(H[3,3])

julia> all_variables(model)
9-element Vector{VariableRef}:
 real(H[1,1])
 real(H[1,2])
 real(H[2,2])
 real(H[1,3])
 real(H[2,3])
 real(H[3,3])
 imag(H[1,2])
 imag(H[1,3])
 imag(H[2,3])

julia> all_constraints(model, Vector{VariableRef}, MOI.HermitianPositiveSemidefiniteConeTriangle)
1-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.HermitianPositiveSemidefiniteConeTriangle}}}:
 [real(H[1,1]), real(H[1,2]), real(H[2,2]), real(H[1,3]), real(H[2,3]), real(H[3,3]), imag(H[1,2]), imag(H[1,3]), imag(H[2,3])] ∈ MathOptInterface.HermitianPositiveSemidefiniteConeTriangle(3)

В выходных данных последних команд мы видим, что было создано девять вещественных переменных. Матрица H ограничивает аффинные выражения этими девятью переменными, которые параметризуют эрмитову матрицу.

# JuMP.LPMatrixData — Type

LPMatrixData{T}

Структура, возвращаемая методом lp_matrix_data. Описание общедоступных полей см. в разделе, посвященном lp_matrix_data.

# JuMP.LessThanZero — Type

GreaterThanZero()

A struct used to intercept when <= or ≤ is used in a macro via operator_to_set.

This struct is not the same as Nonpositives so that we can disambiguate x <= y and x - y in Nonpositives().

This struct is not intended for general usage, but it may be useful to some JuMP extensions.

Example

julia> operator_to_set(error, Val(:<=))
LessThanZero()

# JuMP.LinearTermIterator — Type

LinearTermIterator{GAE<:GenericAffExpr}

Структура, реализующая протокол iterate для итерации по кортежам (coefficient, variable) в GenericAffExpr.

# JuMP.Model — Type

Model([optimizer_factory;] add_bridges::Bool = true)

Создает экземпляр модели JuMP.

Если указан аргумент optimizer_factory, модель инициализируется с оптимизатором, возвращаемым MOI.instantiate(optimizer_factory).

Если аргумент optimizer_factory не указан, используйте set_optimizer, чтобы задать оптимизатор, перед вызовом optimize!.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> solver_name(model)
"Ipopt"

julia> import HiGHS

julia> import MultiObjectiveAlgorithms as MOA

julia> model = Model(() -> MOA.Optimizer(HiGHS.Optimizer); add_bridges = false);

# JuMP.ModelMode — Type

ModelMode

Перечисление для описания состояния CachingOptimizer внутри модели JuMP.

См. также описание метода mode.

Значения

Возможные значения:

# JuMP.NoOptimizer — Type

struct NoOptimizer <: Exception end

Если не установлен необходимый оптимизатор, выдается ошибка.

Оптимизатор можно передать либо в конструктор Model, либо путем вызова set_optimizer.

Пример

julia> model = Model();

julia> optimize!(model)
ERROR: NoOptimizer()
Stacktrace:
[...]

# JuMP.NonlinearConstraintRef — Type

NonlinearConstraintRef

Совместимость

Этот тип является частью устаревшего нелинейного интерфейса. Рекомендуется использовать новый нелинейный интерфейс, который описывается в разделе Nonlinear Modeling.

# JuMP.NonlinearExpr — Type

NonlinearExpr

Псевдоним для GenericNonlinearExpr{VariableRef}, варианта типа GenericNonlinearExpr, используемого в JuMP.

# JuMP.NonlinearExpression — Type

NonlinearExpression <: AbstractJuMPScalar

Структура, представляющая нелинейное выражение.

Выражение создается с помощью макроса @NLexpression.

Совместимость

# JuMP.NonlinearOperator — Type

NonlinearOperator(func::Function, head::Symbol)

Вызываемая структура (функтор), представляющая функцию с именем head.

При вызове с AbstractJuMPScalar эта структура возвращает GenericNonlinearExpr.

При вызове с типами, не относящимися к JuMP, она возвращает результат вычисления func(args...).

Если функция head не представляет собой особый случай для оптимизатора, оператор должен быть уже добавлен в модель с помощью add_nonlinear_operator или @operator.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> f(x::Float64) = x^2
f (generic function with 1 method)

julia> ∇f(x::Float64) = 2 * x
∇f (generic function with 1 method)

julia> ∇²f(x::Float64) = 2.0
∇²f (generic function with 1 method)

julia> @operator(model, op_f, 1, f, ∇f, ∇²f)
NonlinearOperator(f, :op_f)

julia> bar = NonlinearOperator(f, :op_f)
NonlinearOperator(f, :op_f)

julia> @objective(model, Min, bar(x))
op_f(x)

julia> bar(2.0)
4.0

# JuMP.NonlinearParameter — Type

NonlinearParameter <: AbstractJuMPScalar

Структура, представляющая нелинейный параметр.

Параметр создается с помощью макроса @NLparameter.

Совместимость

# JuMP.Nonnegatives — Type

Nonnegatives()

Эквивалент множества MOI.Nonnegatives в JuMP с выводом измерения из соответствующей функции.

Пример

julia> model = Model();

julia> @variable(model, x[1:2])
2-element Vector{VariableRef}:
 x[1]
 x[2]

julia> @constraint(model, x in Nonnegatives())
[x[1], x[2]] ∈ MathOptInterface.Nonnegatives(2)

julia> A = [1 2; 3 4];

julia> b = [5, 6];

julia> @constraint(model, A * x >= b)
[x[1] + 2 x[2] - 5, 3 x[1] + 4 x[2] - 6] ∈ MathOptInterface.Nonnegatives(2)

# JuMP.Nonpositives — Type

Nonpositives()

Эквивалент множества MOI.Nonpositives в JuMP с выводом измерения из соответствующей функции.

Пример

julia> model = Model();

julia> @variable(model, x[1:2])
2-element Vector{VariableRef}:
 x[1]
 x[2]

julia> @constraint(model, x in Nonpositives())
[x[1], x[2]] ∈ MathOptInterface.Nonpositives(2)

julia> A = [1 2; 3 4];

julia> b = [5, 6];

julia> @constraint(model, A * x <= b)
[x[1] + 2 x[2] - 5, 3 x[1] + 4 x[2] - 6] ∈ MathOptInterface.Nonpositives(2)

# JuMP.OptimizeNotCalled — Type

struct OptimizeNotCalled <: Exception end

Если атрибут результата невозможно запросить до вызова optimize!, выдается ошибка.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> objective_value(model)
ERROR: OptimizeNotCalled()
Stacktrace:
[...]

# JuMP.PSDCone — Type

PSDCone

Объект положительно полуопределенного конуса, который можно использовать для ограничения квадратной матрицы положительно полуопределенной формой в макросе @constraint.

Если матрица имеет тип Symmetric, то векторизация столбцов (вектор, полученный путем конкатенации столбцов) ее верхней треугольной части должна принадлежать множеству MOI.PositiveSemidefiniteConeTriangle; в противном случае ее векторизация столбцов должна принадлежать множеству MOI.PositiveSemidefiniteConeSquare.

Пример

Несимметричный случай:

julia> model = Model();

julia> @variable(model, x);

julia> a = [x 2x; 2x x];

julia> b = [1 2; 2 4];

julia> cref = @constraint(model, a >= b, PSDCone())
[x - 1    2 x - 2
 2 x - 2  x - 4] ∈ PSDCone()

julia> jump_function(constraint_object(cref))
4-element Vector{AffExpr}:
 x - 1
 2 x - 2
 2 x - 2
 x - 4

julia> moi_set(constraint_object(cref))
MathOptInterface.PositiveSemidefiniteConeSquare(2)

Симметричный случай:

julia> using LinearAlgebra # Для Symmetric

julia> model = Model();

julia> @variable(model, x);

julia> a = [x 2x; 2x x];

julia> b = [1 2; 2 4];

julia> cref = @constraint(model, Symmetric(a - b) in PSDCone())
[x - 1  2 x - 2
 ⋯      x - 4] ∈ PSDCone()

julia> jump_function(constraint_object(cref))
3-element Vector{AffExpr}:
 x - 1
 2 x - 2
 x - 4

julia> moi_set(constraint_object(cref))
MathOptInterface.PositiveSemidefiniteConeTriangle(2)

# JuMP.Parameter — Type

Parameter(value)

Сокращение для множества MOI.Parameter.

Пример

julia> model = Model();

julia> @variable(model, x in Parameter(2))
x

julia> print(model)
Feasibility
Subject to
 x ∈ MathOptInterface.Parameter{Float64}(2.0)

# JuMP.QuadExpr — Type

QuadExpr

Псевдоним для GenericQuadExpr{Float64,VariableRef}, варианта типа GenericQuadExpr, используемого в JuMP.

# JuMP.QuadTermIterator — Type

QuadTermIterator{GQE<:GenericQuadExpr}

Структура, реализующая протокол iterate для итерации по кортежам (coefficient, variable, variable) в GenericQuadExpr.

# JuMP.RotatedSecondOrderCone — Type

RotatedSecondOrderCone

Объект повернутого конуса второго порядка, который можно использовать для ограничения квадрата евклидовой нормы вектора x значением меньше или равным , где t и u — неотрицательные скалярные значения. Сокращение для MOI.RotatedSecondOrderCone.

Пример

Следующий код налагает ограничения и :

julia> model = Model();

julia> @variable(model, x)
x

julia> @variable(model, t)
t

julia> @constraint(model, [t, x, x-1, x-2] in RotatedSecondOrderCone())
[t, x, x - 1, x - 2] ∈ MathOptInterface.RotatedSecondOrderCone(4)

# JuMP.SOS1 — Type

SOS1(weights = Real[])

Множество SOS1 (особое упорядоченное множество типа 1) ограничивает вектор x множеством, в котором максимум одна переменная может принимать ненулевое значение, а остальные элементы равны нулю.

Вектор weights, если он указан, обеспечивает упорядочение переменных; по этой причине он должен содержать уникальные значения. Вектор weights должен иметь то же количество элементов, что и вектор x, а элемент weights[i] соответствует элементу x[i]. Если вектор weights не указан, по умолчанию он равен weights[i] = i.

Это сокращение для множества MOI.SOS1.

Пример

julia> model = Model();

julia> @variable(model, x[1:3] in SOS1([4.1, 3.2, 5.0]))
3-element Vector{VariableRef}:
 x[1]
 x[2]
 x[3]

julia> print(model)
Feasibility
Subject to
 [x[1], x[2], x[3]] ∈ MathOptInterface.SOS1{Float64}([4.1, 3.2, 5.0])

# JuMP.SOS2 — Type

SOS2(weights = Real[])

Множество SOS2 (особое упорядоченное множество типа 2) ограничивает вектор x множеством, в котором максимум две переменные могут принимать ненулевое значение, а остальные элементы равны нулю. Кроме того, два ненулевых значения должны быть последовательными, учитывая порядок элементов вектора x, обеспечиваемый вектором weights.

Это сокращение для множества MOI.SOS2.

Пример

julia> model = Model();

julia> @variable(model, x[1:3] in SOS2([4.1, 3.2, 5.0]))
3-element Vector{VariableRef}:
 x[1]
 x[2]
 x[3]

julia> print(model)
Feasibility
Subject to
 [x[1], x[2], x[3]] ∈ MathOptInterface.SOS2{Float64}([4.1, 3.2, 5.0])

# JuMP.ScalarConstraint — Type

struct ScalarConstraint

Данные для скалярного ограничения.

Дополнительные сведения см. также в документации по представлению ограничений в JuMP.

Поля

.func: поле содержит объект JuMP, представляющий функцию.
.set: поле содержит множество MOI.

Пример

Скалярное ограничение:

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, 2x <= 1)
c : 2 x ≤ 1

julia> object = constraint_object(c)
ScalarConstraint{AffExpr, MathOptInterface.LessThan{Float64}}(2 x, MathOptInterface.LessThan{Float64}(1.0))

julia> typeof(object)
ScalarConstraint{AffExpr, MathOptInterface.LessThan{Float64}}

julia> object.func
2 x

julia> object.set
MathOptInterface.LessThan{Float64}(1.0)

# JuMP.ScalarShape — Type

ScalarShape()

Объект AbstractShape, представляющий скалярные ограничения.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> c = @constraint(model, x[2] <= 1);

julia> shape(constraint_object(c))
ScalarShape()

# JuMP.ScalarVariable — Type

ScalarVariable{S,T,U,V} <: AbstractVariable

Структура, используемая при добавлении переменных.

См. также описание функции add_variable.

# JuMP.SecondOrderCone — Type

SecondOrderCone

Объект конуса второго порядка, который можно использовать для ограничения евклидовой нормы вектора x значением меньше или равным неотрицательной скалярной величине t. Сокращение для MOI.SecondOrderCone.

Пример

Следующий код налагает ограничения и :

julia> model = Model();

julia> @variable(model, x)
x

julia> @variable(model, t)
t

julia> @constraint(model, [t, x-1, x-2] in SecondOrderCone())
[t, x - 1, x - 2] ∈ MathOptInterface.SecondOrderCone(3)

# JuMP.Semicontinuous — Type

Semicontinuous(lower, upper)

Сокращение для множества MOI.Semicontinuous.

Это сокращение полезно тем, что оно автоматически продвигает lower и upper до одного типа и преобразует их в тип элемента, поддерживаемый моделью JuMP.

Пример

julia> model = Model();

julia> @variable(model, x in Semicontinuous(1, 2))
x

julia> print(model)
Feasibility
Subject to
 x ∈ MathOptInterface.Semicontinuous{Int64}(1, 2)

# JuMP.Semiinteger — Type

Semiinteger(lower, upper)

Сокращение для множества MOI.Semiinteger.

Пример

julia> model = Model();

julia> @variable(model, x in Semiinteger(3, 5))
x

julia> print(model)
Feasibility
Subject to
 x ∈ MathOptInterface.Semiinteger{Int64}(3, 5)

# JuMP.SensitivityReport — Type

SensitivityReport

См. описание метода lp_sensitivity_report.

# JuMP.SkewSymmetricMatrixShape — Type

SkewSymmetricMatrixShape

Объект формы для кососимметричной квадратной матрицы из side_dimension строк и столбцов. Векторизованная форма содержит элементы верхней правой треугольной части матрицы (без диагонали) по столбцам (или, что то же самое, элементы нижней левой треугольной части по строкам). Диагональ равна нулю.

# JuMP.SkewSymmetricMatrixSpace — Type

SkewSymmetricMatrixSpace()

Используется в макросе @variable, ограничивая матрицу переменных кососимметричной формой.

Пример

julia> model = Model();

julia> @variable(model, Q[1:2, 1:2] in SkewSymmetricMatrixSpace())
2×2 Matrix{AffExpr}:
 0        Q[1,2]
 -Q[1,2]  0

# JuMP.SkipModelConvertScalarSetWrapper — Type

SkipModelConvertScalarSetWrapper(set::MOI.AbstractScalarSet)

JuMP использует model_convert](api.md#JuMP.model_convert-Tuple{AbstractModel, Any}) для автоматического продвижения множеств [MOI.AbstractScalarSet до того же типа value_type, что и у модели.

Если это нежелательно, заключите множество в SkipModelConvertScalarSetWrapper, чтобы передать его в решатель в исходном виде.

Эта структура предназначена для внутреннего использования в расширениях JuMP. Необходимость использовать ее в обычном коде JuMP не должна возникать.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, x in MOI.EqualTo(1 // 2))
x = 0.5

julia> @constraint(model, x in SkipModelConvertScalarSetWrapper(MOI.EqualTo(1 // 2)))
x = 1//2

# JuMP.SquareMatrixShape — Type

SquareMatrixShape

Объект формы для квадратной матрицы из side_dimension строк и столбцов. Векторизованная форма содержит элементы матрицы по столбцам (или, что то же самое, элементы нижней левой треугольной части по строкам).

# JuMP.SymmetricMatrixAdjointShape — Type

SymmetricMatrixAdjointShape(side_dimension)

The dual_shape of SymmetricMatrixShape.

This shape is not intended for regular use.

# JuMP.SymmetricMatrixShape — Type

SymmetricMatrixShape

Объект формы для симметричной квадратной матрицы из side_dimension строк и столбцов. Векторизованная форма содержит элементы верхней правой треугольной части матрицы по столбцам (или, что то же самое, элементы нижней левой треугольной части по строкам).

# JuMP.SymmetricMatrixSpace — Type

SymmetricMatrixSpace()

Используется в макросе @variable, ограничивая матрицу переменных симметричной формой.

Пример

julia> model = Model();

julia> @variable(model, Q[1:2, 1:2] in SymmetricMatrixSpace())
2×2 LinearAlgebra.Symmetric{VariableRef, Matrix{VariableRef}}:
 Q[1,1]  Q[1,2]
 Q[1,2]  Q[2,2]

# JuMP.UnorderedPair — Type

UnorderedPair(a::T, b::T)

Тип-оболочка, используемый типом GenericQuadExpr, с полями .a и .b.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> expr = 2.0 * x[1] * x[2]
2 x[1]*x[2]

julia> expr.terms
OrderedCollections.OrderedDict{UnorderedPair{VariableRef}, Float64} with 1 entry:
  UnorderedPair{VariableRef}(x[1], x[2]) => 2.0

# JuMP.VariableConstrainedOnCreation — Type

VariableConstrainedOnCreation <: AbstractVariable

Переменная scalar_variables, которая должна принадлежать множеству set.

Добавление этой переменной равносильно следующему коду:

function JuMP.add_variable(
    model::GenericModel,
    variable::VariableConstrainedOnCreation,
    names,
)
    var_ref = add_variable(model, variable.scalar_variable, name)
    add_constraint(model, VectorConstraint(var_ref, variable.set))
    return var_ref
end

однако вместо этого переменные добавляются с помощью вызова MOI.add_constrained_variable(model, variable.set).

# JuMP.VariableInfo — Type

VariableInfo{S,T,U,V}

Внутренняя структура JuMP, используемая при создании переменных. Также может использоваться расширениями JuMP для создания новых типов переменных.

См. также описание типа ScalarVariable.

# JuMP.VariableNotOwned — Type

struct VariableNotOwned{V<:AbstractVariableRef} <: Exception
    variable::V
end

Переменная variable использовалась в модели, отличной от owner_model(variable).

# JuMP.VariablesConstrainedOnCreation — Type

VariablesConstrainedOnCreation <: AbstractVariable

Вектор переменных scalar_variables, которые должны принадлежать множеству set. Добавление этой переменной равносильно следующему коду:

function JuMP.add_variable(
    model::GenericModel,
    variable::VariablesConstrainedOnCreation,
    names,
)
    v_names = vectorize(names, variable.shape)
    var_refs = add_variable.(model, variable.scalar_variables, v_names)
    add_constraint(model, VectorConstraint(var_refs, variable.set))
    return reshape_vector(var_refs, variable.shape)
end

однако вместо этого переменные добавляются с помощью вызова MOI.add_constrained_variables(model, variable.set). Сведения о различии между добавлением переменных с помощью MOI.add_constrained_variables и их добавлении с помощью MOI.add_variables с добавлением ограничения отдельно см. в документации по MOI.

# JuMP.VectorConstraint — Type

struct VectorConstraint

Данные для векторного ограничения.

См. также документацию по представлению ограничений в JuMP.

Поля

func: поле содержит объект JuMP, представляющий функцию.
set: поле содержит множество MOI.
shape: поле содержит объект AbstractShape, соответствующий форме, в которой было создано ограничение (например, с использованием матриц или плоских векторов).

Пример

julia> model = Model();

julia> @variable(model, x[1:3]);

julia> @constraint(model, c, x in SecondOrderCone())
c : [x[1], x[2], x[3]] ∈ MathOptInterface.SecondOrderCone(3)

julia> object = constraint_object(c)
VectorConstraint{VariableRef, MathOptInterface.SecondOrderCone, VectorShape}(VariableRef[x[1], x[2], x[3]], MathOptInterface.SecondOrderCone(3), VectorShape())

julia> typeof(object)
VectorConstraint{VariableRef, MathOptInterface.SecondOrderCone, VectorShape}

julia> object.func
3-element Vector{VariableRef}:
 x[1]
 x[2]
 x[3]

julia> object.set
MathOptInterface.SecondOrderCone(3)

julia> object.shape
VectorShape()

# JuMP.VectorShape — Type

VectorShape()

Объект AbstractShape, представляющий векторнозначные ограничения.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> c = @constraint(model, x in SOS1());

julia> shape(constraint_object(c))
VectorShape()

# JuMP.Zeros — Type

Zeros()

Эквивалент множества MOI.Zeros в JuMP с выводом измерения из соответствующей функции.

Пример

julia> model = Model();

julia> @variable(model, x[1:2])
2-element Vector{VariableRef}:
 x[1]
 x[2]

julia> @constraint(model, x in Zeros())
[x[1], x[2]] ∈ MathOptInterface.Zeros(2)

julia> A = [1 2; 3 4];

julia> b = [5, 6];

julia> @constraint(model, A * x == b)
[x[1] + 2 x[2] - 5, 3 x[1] + 4 x[2] - 6] ∈ MathOptInterface.Zeros(2)

# JuMP._VariableValueMap — _Type

_VariableValueMap{F}

Отложенный кэш, используемый для вычисления прямого решения для переменных в value.

Избавляет от необходимости переписывать нелинейные выражения из MOI*VARIABLE в VARIABLE, а также немедленно вычислять var*valueдля каждой переменной.cache используется для того, чтобы не приходилось заново вычислять переменные, которые уже встречались.

# Base.copy — Method

copy(model::AbstractModel)

Возвращает копию модели model. Действует аналогично copy_model за тем исключением, что не возвращает сопоставление между ссылками модели model и ее копии.

Примечание

Копирование модели не поддерживается в режиме DIRECT, то есть когда модель создается с помощью конструктора direct_model, а не конструктора Model. К тому же независимо от того, был ли предоставлен оптимизатор при создании модели, у новой модели не будет оптимизатора, то есть ей необходимо предоставить оптимизатор в вызове optimize!.

Пример

В следующем примере создается модель model с переменной x и ограничением cref. Затем она копируется в модель new_model с новыми ссылками, присвоенными x_new и cref_new.

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, cref, x == 2)
cref : x = 2

julia> new_model = copy(model);

julia> x_new = model[:x]
x

julia> cref_new = model[:cref]
cref : x = 2

# Base.empty! — Method

empty!(model::GenericModel)::GenericModel

Очищает модель, то есть удаляет все переменные, ограничения и атрибуты модели, но не атрибуты оптимизатора. Всегда возвращает аргумент.

Примечание: удаляет данные расширений.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> isempty(model)
false

julia> empty!(model)
A JuMP Model
Feasibility problem with:
Variables: 0
Model mode: AUTOMATIC
CachingOptimizer state: NO_OPTIMIZER
Solver name: No optimizer attached.

julia> print(model)
Feasibility
Subject to

julia> isempty(model)
true

# Base.getindex — Method

Base.getindex(m::JuMP.AbstractModel, name::Symbol)

Упрощает доступ к переменным и ограничениям JuMP посредством синтаксиса [].

Возвращает переменную или группу переменных (либо ограничение или группу ограничений) с указанным именем, которые были добавлены в модель. Если несколько переменных или ограничений имеют одно и то же имя, возникает ошибка.

# Base.haskey — Method

haskey(model::AbstractModel, name::Symbol)

Определяет, есть ли в модели сопоставление для данного имени.

# Base.isempty — Method

isempty(model::GenericModel)

Проверяет, является ли модель пустой, то есть пуст ли бэкенд MOI и находится ли модель в том же состоянии, что и при ее создании, за исключением атрибутов оптимизатора.

Пример

julia> model = Model();

julia> isempty(model)
true

julia> @variable(model, x[1:2]);

julia> isempty(model)
false

# Base.read — Method

Base.read(
    io::IO,
    ::Type{<:GenericModel};
    format::MOI.FileFormats.FileFormat,
    kwargs...,
)

Возвращает модель JuMP, считанную из io, в формате format.

Другие аргументы kwargs передаются в конструктор Model выбранного формата.

# Base.setindex! — Method

Base.setindex!(m::JuMP.AbstractModel, value, name::Symbol)

Сохраняет объект value в модели m, чтобы к нему можно было получить доступ посредством getindex. Может вызываться с использованием синтаксиса [].

# Base.show — _Method

Base.show([io::IO], summary::SolutionSummary; verbose::Bool = false)

Записывает сводку результатов решения в io (или в stdout, если аргумент io не указан).

# Base.write — Method

Base.write(
    io::IO,
    model::GenericModel;
    format::MOI.FileFormats.FileFormat = MOI.FileFormats.FORMAT_MOF,
    kwargs...,
)

Записывает модель JuMP model в io в формате format.

Другие аргументы kwargs передаются в конструктор Model выбранного формата.

# JuMP.BinaryRef — Method

BinaryRef(v::GenericVariableRef)

Возвращает ссылку на ограничение, делающее переменную v двоичной. Если ее не существует, выдает ошибку.

См. также описание is_binary, set_binary и unset_binary.

Пример

julia> model = Model();

julia> @variable(model, x, Bin);

julia> BinaryRef(x)
x binary

# JuMP.FixRef — Method

FixRef(v::GenericVariableRef)

Возвращает ссылку на ограничение, фиксирующее значение переменной v.

Если ее не существует, выдает ошибку.

См. также описание is_fixed, fix_value, fix и unfix.

Пример

julia> model = Model();

julia> @variable(model, x == 1);

julia> FixRef(x)
x = 1

# JuMP.IntegerRef — Method

IntegerRef(v::GenericVariableRef)

Возвращает ссылку на ограничение, делающее переменную v целочисленной.

Если ее не существует, выдает ошибку.

См. также описание is_integer, set_integer и unset_integer.

Пример

julia> model = Model();

julia> @variable(model, x, Int);

julia> IntegerRef(x)
x integer

# JuMP.LowerBoundRef — Method

LowerBoundRef(v::GenericVariableRef)

Возвращает ссылку на ограничение нижней границы переменной v.

Если ее не существует, выдает ошибку.

См. также описание has_lower_bound, lower_bound, set_lower_bound и delete_lower_bound.

Пример

julia> model = Model();

julia> @variable(model, x >= 1.0);

julia> LowerBoundRef(x)
x ≥ 1

# JuMP.NLPEvaluator — Method

NLPEvaluator(
    model::Model,
    _differentiation_backend::MOI.Nonlinear.AbstractAutomaticDifferentiation =
        MOI.Nonlinear.SparseReverseMode(),
)

Возвращает объект MOI.AbstractNLPEvaluator, созданный на основе model

Перед использованием средства оценки его необходимо инициализировать с помощью MOI.initialize.

Экспериментальные функции

Эти функции могут быть изменены или удалены в любой будущей версии JuMP.

Передайте _differentiation_backend, чтобы указать бэкенд дифференцирования для вычисления производных.

# JuMP.ParameterRef — Method

ParameterRef(x::GenericVariableRef)

Возвращает ссылку на ограничение, делающее x параметром.

Если ее не существует, выдает ошибку.

См. также описание is_parameter, set_parameter_value и parameter_value.

Пример

julia> model = Model();

julia> @variable(model, p in Parameter(2))
p

julia> ParameterRef(p)
p ∈ MathOptInterface.Parameter{Float64}(2.0)

julia> @variable(model, x);

julia> ParameterRef(x)
ERROR: Variable x is not a parameter.
Stacktrace:
[...]

# JuMP.UpperBoundRef — Method

UpperBoundRef(v::GenericVariableRef)

Возвращает ссылку на ограничение верхней границы переменной v.

Если ее не существует, выдает ошибку.

См. также описание has_upper_bound, upper_bound, set_upper_bound и delete_upper_bound.

Пример

julia> model = Model();

julia> @variable(model, x <= 1.0);

julia> UpperBoundRef(x)
x ≤ 1

# JuMP._compute_rhs_range — _Method

_compute_rhs_range(d_B, x_B, l_B, u_B, atol)

Предположим, что мы начинаем с оптимального решения x_old и хотим вычислить размер шага t в направлении d таким образом, чтобы x_new = x_old + t * d по-прежнему было представлено тем же оптимальным базисом. Это можно вычислить по методу простого симплекса с использованием искусственной входящей переменной.

A * x_new = A * (x_old + t * d)
            = A * x_old + t * A * d
            = 0         + t * A * d  # Так как A * x_old = 0
=>  A * d = 0
=> B * d_B + N * d_N = 0
=> d_B = B \ -(N * d_N)

Обратите внимание, что нам нужно вычислить только базовый компонент вектора направления, так как d_N — это просто нули с 1 в компоненте, связанном с искусственной входящей переменной. Поэтому остается лишь вычислить связанный столбец N.

Если увеличить границы, связанные с i-й переменной решения, то искусственная входящая переменная будет копией i-й переменной, а N * d_N = A[:, i].

Если увеличить границы, связанные с i-м аффинным ограничением, то искусственная входящая переменная будет копией ослабляющей переменной, связанной с i-м ограничением, то есть -1 в i-й строке и нули в остальных.

В любом случае:

d_B = -(B \ A[:, i])

Мы вычислили направление такое, что x_new = x_old + t * d. Благодаря соблюдению условия A * d = 0 мы обеспечили структурную допустимость. Теперь необходимо вычислить границы для t так, чтобы x_new сохраняло допустимость границ. Иначе говоря, нужно вычислить границы для t, чтобы было верно следующее:

l_B[j] <= x_B[j] + t * d_B[j] <= u_B[j].

# JuMP._desparsify — _Method

_desparsify(x)

Если x — это массив AbstractSparseArray, возвращает плотный эквивалент; в противном случае просто возвращает x.

Эта функция используется в _build_constraint.

Зачем она нужна?

При трансляции f.(x) через AbstractSparseArray x Julia сначала вызывает эквивалент f(zero(eltype(x)). Вот пример:

julia> import SparseArrays

julia> foo(x) = (println("Calling $(x)"); x)
foo (generic function with 1 method)

julia> foo.(SparseArrays.sparsevec([1, 2], [1, 2]))
Calling 1
Calling 2
2-element SparseArrays.SparseVector{Int64, Int64} with 2 stored entries:
  [1]  =  1
  [2]  =  2

Однако если функция f является изменяющей, это может иметь серьезные последствия! В нашем случае при трансляции build_constraint добавляется новое ограничение 0 = 0.

Разреженные массивы чаще всего образуются, когда разреженными являются входные данные для ограничения (например, константный вектор или матрица). Из-за продвижения и арифметических операций получается функция ограничения, которая представлена массивом AbstractSparseArray, но на самом деле является плотной. Поэтому можно спокойно собрать (collect) матрицу в плотный массив.

Если функция разреженная, порядок действий неочевиден. Каким будет «нулевой» элемент результата? Что означает трансляция build_constraint по разреженному массиву с добавлением скалярных ограничений? Скорее всего, это означает, что пользователь применяет неправильную структуру данных. Для простоты давайте также будем вызывать collect для плотного массива и посмотрим, будут ли проблемы.

# JuMP._eval_as_variable — _Method

_eval_as_variable(f::F, x::GenericAffExpr, args...) where {F}

Зачастую макрос @variable может возвращать GenericAffExpr вместо GenericVariableRef. Это особенно актуально для выражений с комплексными значениями. Чтобы могли выполняться стандартные операции, такие как lower_bound(x), метод следует перенаправлять тогда и только тогда, когда x можно преобразовать в GenericVariableRef.

# JuMP._fill_vaf! — _Method

_fill_vaf!(
    terms::Vector{<:MOI.VectorAffineTerm},
    offset::Int,
    oi::Int,
    aff::AbstractJuMPScalar,
)

Заполняет члены векторов с индексами, начинающимися с offset+1, аффинными членами aff. Выходной индекс для всех членов — oi. Возвращает индекс последнего добавленного члена.

# JuMP._fill_vqf! — _Method

_fill_vqf!(terms::Vector{<:MOI.VectorQuadraticTerm}, offset::Int, oi::Int,
           quad::AbstractJuMPScalar)

Заполняет члены векторов с индексами, начинающимися с offset+1, квадратичными членами quad. Выходной индекс для всех членов — oi. Возвращает индекс последнего добавленного члена.

# JuMP._finalize_macro — _Method

_finalize_macro(
    model,
    code,
    source::LineNumberNode;
    register_name::Union{Nothing,Symbol} = nothing,
    wrap_let::Bool = false,
)

Заключает сгенерированный макросом код code в блок кода с первым аргументом source, то есть узлом LineNumberNode, из которого был вызван макрос в пользовательском коде. Улучшает трассировки стека в сообщениях об ошибках.

Помимо этого, данная функция проверяет, является ли модель model допустимым объектом AbstractModel.

Если register_name имеет тип Symbol, результат выполнения кода code в модели model регистрируется под именем register_name.

Если wrap_let, код code заключается в блок let model = model, что делает модель локальной переменной.

# JuMP._is_lp — _Method

_is_lp(model::GenericModel)

Возвращает true, если model является линейной программой.

# JuMP._moi_quadratic_term — _Method

_moi_quadratic_term(t::Tuple)

Возвращает MOI.ScalarQuadraticTerm для квадратичного члена t, элемента итератора quad_terms. Обратите внимание, что ссылки VariableRef преобразуются в индексы MOI.VariableIndex, поэтому информация о модели-владельце теряется.

# JuMP._nlp_objective_function — _Method

_nlp_objective_function(model::GenericModel)

Возвращает нелинейную целевую функцию или nothing, если она не задана.

# JuMP._parse_nonlinear_expression — _Method

_parse_nonlinear_expression(model::GenericModel, x::Expr)

JuMP необходимо создавать объекты нелинейных выражений в области макроса. При этом возникают две основные проблемы:

Локальные переменные должны вычисляться в выражениях. Это довольно

просто: любой символ, не являющийся вызовом функции, заменяется на esc(x).

Необходимо определить незарегистрированные пользовательские функции, чтобы можно было

попытаться автоматически зарегистрировать их, если их символьные имена существуют в области. Автоматическая регистрация была изначально введена мною (@odow) в https://github.com/jump-dev/JuMP.jl/pull/2537 для устранения частой проблемы в JuMP, но по прошествии времени я считаю, что это было ошибкой. Возникает множество неудобств! Одна из проблем заключается в том, что анализ нелинейных выражений сместился со времени расширения макроса на время выполнения. Я думаю, что это большой плюс для удобочитаемости системы, но это означает, что мы теряем доступ к локальной области вызывающей стороны. Мое решение для поддержания обратной совместимости — проверять, зарегистрирован ли каждый вызов функции, перед анализом выражения.

# JuMP._print_latex — _Method

_print_latex(io::IO, model::AbstractModel)

Выводит формулировку LaTeX модели model в io.

Чтобы этот метод работал, необходимо реализовать подтип AbstractModel:

objective_function_string
constraints_string
_nl_subexpression_string

# JuMP._print_model — _Method

_print_model(io::IO, model::AbstractModel)

Выводит формулировку модели model в виде обычного текста в io.

Чтобы этот метод работал, необходимо реализовать подтип AbstractModel:

objective_function_string
constraints_string
_nl_subexpression_string

# JuMP._print_summary — _Method

_print_summary(io::IO, model::AbstractModel)

Выводит сводку модели model в виде обычного текста в io.

Чтобы этот метод работал, необходимо реализовать подтип AbstractModel:

name(::AbstractModel)
show_objective_function_summary
show_constraints_summary
show_backend_summary

# JuMP._replace_zero — _Method

_replace_zero(model::M, x) where {M<:AbstractModel}

Заменяет _MA.Zero на zero(value_type(M)) с плавающей запятой.

# JuMP._rewrite_expression — _Method

_rewrite_expression(expr)

Если объект expr не является Expr, при его перезаписи ничего не происходит. Если он изменяемый, нужно просто скопировать его, чтобы последующие операции не изменяли данные пользователя.

# JuMP._rewrite_expression — _Method

_rewrite_expression(expr)

Вспомогательная функция, позволяющая определять способ перезаписи выражений в одном месте и распространять его на все места в макросах JuMP, которые переписывают выражения.

# JuMP._standard_form_matrix — _Method

_standard_form_matrix(model::GenericModel)

См. вместо этого описание метода lp_matrix_data.

# JuMP.add_bridge — Method

add_bridge(
    model::GenericModel{T},
    BT::Type{<:MOI.Bridges.AbstractBridge};
    coefficient_type::Type{S} = T,
) where {T,S}

Добавляет BT{T} в список мостов, которые можно использовать для преобразования неподдерживаемых ограничений в эквивалентную форму, поддерживаемую оптимизатором.

См. также описание метода remove_bridge.

Пример

julia> model = Model();

julia> add_bridge(model, MOI.Bridges.Constraint.SOCtoNonConvexQuadBridge)

julia> add_bridge(
           model,
           MOI.Bridges.Constraint.NumberConversionBridge;
           coefficient_type = Complex{Float64}
       )

# JuMP.add_constraint — Function

add_constraint(
    model::GenericModel,
    con::AbstractConstraint,
    name::String= "",
)

Этот метод следует реализовывать только разработчикам, создающим расширения JuMP. Он ни в коем случае не должен вызываться пользователями JuMP.

# JuMP.add_nonlinear_constraint — Method

add_nonlinear_constraint(model::Model, expr::Expr)

Добавляет нелинейное ограничение, описываемое выражением Julia ex, в model.

Эта функция наиболее полезна в случае, если выражение ex генерируется программным образом и использовать @NLconstraint невозможно.

Совместимость

Эта функция является частью устаревшего нелинейного интерфейса. Рекомендуется использовать новый нелинейный интерфейс, который описывается в разделе Nonlinear Modeling.

Примечания

Переменные следует интерполировать напрямую в выражение expr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> add_nonlinear_constraint(model, :($(x) + $(x)^2 <= 1))
(x + x ^ 2.0) - 1.0 ≤ 0

# JuMP.add_nonlinear_expression — Method

add_nonlinear_expression(model::Model, expr::Expr)

Добавляет нелинейное выражение expr в model.

Эта функция наиболее полезна в случае, если выражение expr генерируется программным образом и использовать @NLexpression невозможно.

Совместимость

Примечания

Переменные следует интерполировать напрямую в выражение expr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> add_nonlinear_expression(model, :($(x) + $(x)^2))
subexpression[1]: x + x ^ 2.0

# JuMP.add_nonlinear_operator — Method

add_nonlinear_operator(
    model::Model,
    dim::Int,
    f::Function,
    [∇f::Function,]
    [∇²f::Function];
    [name::Symbol = Symbol(f),]
)

Добавляет новый нелинейный оператор с dim входных аргументов в model и связывает его с именем name.

Функция f вычисляет оператор и должна возвращать скалярное значение.

Необязательная функция ∇f вычисляет первую производную, а необязательная функция ∇²f — вторую производную.

Функцию ∇²f можно передать только в том случае, если передана функция ∇f.

Одномерный синтаксис

При dim == 1 сигнатуры методов каждой функции должны быть следующими:

f(::T)::T where {T<:Real}
∇f(::T)::T where {T<:Real}
∇²f(::T)::T where {T<:Real}

Многомерный синтаксис

При dim > 1 сигнатуры методов каждой функции должны быть следующими:

f(x::T...)::T where {T<:Real}
∇f(g::AbstractVector{T}, x::T...)::Nothing where {T<:Real}
∇²f(H::AbstractMatrix{T}, x::T...)::Nothing where {T<:Real}

Где градиентный вектор g и гессианова матрица H заполняются на месте. Для гессиана необходимо заполнять только ненулевые элементы нижнего треугольника. Задание недиагонального элемента верхнего треугольника может привести к ошибке.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> f(x::Float64) = x^2
f (generic function with 1 method)

julia> ∇f(x::Float64) = 2 * x
∇f (generic function with 1 method)

julia> ∇²f(x::Float64) = 2.0
∇²f (generic function with 1 method)

julia> op_f = add_nonlinear_operator(model, 1, f, ∇f, ∇²f)
NonlinearOperator(f, :f)

julia> @objective(model, Min, op_f(x))
f(x)

julia> op_f(2.0)
4.0

# JuMP.add_nonlinear_parameter — Method

add_nonlinear_parameter(model::Model, value::Real)

Добавляет в модель анонимный параметр.

Совместимость

# JuMP.add_to_expression! — Function

add_to_expression!(expression, terms...)

Обновляет выражение expression на месте до expression + (*)(terms...).

Обычно это намного эффективнее, чем expression += (*)(terms...), поскольку позволяет избежать временного размещения в памяти члена из правой части.

Например, add_to_expression!(expression, a, b) дает тот же результат, что и expression += a*b, а add_to_expression!(expression, a) дает тот же результат, что и expression += a.

Условия реализации

Определено лишь несколько методов, преимущественно для внутреннего использования и только для следующих случаев:

Методы могут быть эффективно реализованы.
expression может сохранять результат. Например, метод

add_to_expression!(::AffExpr, ::GenericVariableRef, ::GenericVariableRef) не определен, так как GenericAffExpr не может сохранять произведение двух переменных.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> expr = 2 + x
x + 2

julia> add_to_expression!(expr, 3, x)
4 x + 2

julia> expr
4 x + 2

# JuMP.add_to_function_constant — Method

add_to_function_constant(constraint::ConstraintRef, value)

Прибавляет value к свободному члену функции constraint.

Обратите внимание, что для скалярных ограничений JuMP выводит все свободные члены в правую часть ограничения, поэтому вместо изменения функции множество будет преобразовано на -value. Например, ограничение 2x <= 3 метод add_to_function_constant(c, 4) изменит на 2x <= -1.

Пример

Для скалярных ограничений множество преобразуется на -value:

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, con, 0 <= 2x - 1 <= 2)
con : 2 x ∈ [1, 3]

julia> add_to_function_constant(con, 4)

julia> con
con : 2 x ∈ [-3, -1]

Для векторных ограничений константа прибавляется к функции:

julia> model = Model();

julia> @variable(model, x);

julia> @variable(model, y);

julia> @constraint(model, con, [x + y, x, y] in SecondOrderCone())
con : [x + y, x, y] ∈ MathOptInterface.SecondOrderCone(3)

julia> add_to_function_constant(con, [1, 2, 2])

julia> con
con : [x + y + 1, x + 2, y + 2] ∈ MathOptInterface.SecondOrderCone(3)

# JuMP.add_variable — Function

add_variable(m::GenericModel, v::AbstractVariable, name::String = "")

# JuMP.all_constraints — Method

all_constraints(model::GenericModel, function_type, set_type)::Vector{<:ConstraintRef}

Возвращает список всех ограничений, которые в настоящее время имеются в модели, где функция имеет тип function_type, а множество — тип set_type. Ограничения упорядочены по времени создания.

См. также описание методов list_of_constraint_types и num_constraints.

Пример

julia> model = Model();

julia> @variable(model, x >= 0, Bin);

julia> @constraint(model, 2x <= 1);

julia> all_constraints(model, VariableRef, MOI.GreaterThan{Float64})
1-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, ScalarShape}}:
 x ≥ 0

julia> all_constraints(model, VariableRef, MOI.ZeroOne)
1-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}, ScalarShape}}:
 x binary

julia> all_constraints(model, AffExpr, MOI.LessThan{Float64})
1-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, ScalarShape}}:
 2 x ≤ 1

# JuMP.all_constraints — Method

all_constraints(
    model::GenericModel;
    include_variable_in_set_constraints::Bool,
)::Vector{ConstraintRef}

Возвращает список всех ограничений в model.

При include_variable_in_set_constraints == true включаются ограничения VariableRef, такие как «VariableRef в Integer». Чтобы возвращались только структурные ограничения (например, строки в матрице ограничений линейной программы), передайте include_variable_in_set_constraints = false.

Пример

julia> model = Model();

julia> @variable(model, x >= 0, Int);

julia> @constraint(model, 2x <= 1);

julia> @NLconstraint(model, x^2 <= 1);

julia> all_constraints(model; include_variable_in_set_constraints = true)
4-element Vector{ConstraintRef}:
 2 x ≤ 1
 x ≥ 0
 x integer
 x ^ 2.0 - 1.0 ≤ 0

julia> all_constraints(model; include_variable_in_set_constraints = false)
2-element Vector{ConstraintRef}:
 2 x ≤ 1
 x ^ 2.0 - 1.0 ≤ 0

Замечания по производительности

Обратите внимание, что эта функция нестабильна по типу, так как возвращает вектор абстрактного типа. Если производительность важна, рекомендуется использовать list_of_constraint_types](api.md#JuMP.list_of_constraint_types-Tuple{GenericModel}) и функциональный барьер. Дополнительные сведения см. в разделе [Performance tips for extensions документации.

# JuMP.all_nonlinear_constraints — Method

all_nonlinear_constraints(model::GenericModel)

Возвращает вектор всех ссылок на нелинейные ограничения в модели в том порядке, в котором они были добавлены в модель.

Совместимость

Эта функция возвращает только те ограничения, которые были добавлены с помощью @NLconstraint и add_nonlinear_constraint. Она не возвращает ограничения GenericNonlinearExpr.

# JuMP.all_variables — Method

all_variables(model::GenericModel{T})::Vector{GenericVariableRef{T}} where {T}

Возвращает список всех переменных, имеющихся в настоящее время в модели. Переменные упорядочены по времени создания.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @variable(model, y);

julia> all_variables(model)
2-element Vector{VariableRef}:
 x
 y

# JuMP.anonymous_name — Method

anonymous_name(::MIME, x::AbstractVariableRef)

Имя, используемое для анонимной переменной x при выводе.

Пример

julia> model = Model();

julia> x = @variable(model);

julia> anonymous_name(MIME("text/plain"), x)
"_[1]"

# JuMP.backend — Method

backend(model::GenericModel)

Возвращает низкоуровневую модель MathOptInterface, на которой основана модель JuMP. Эта модель зависит от режима работы JuMP (см. описание метода mode).

Если JuMP работает в режиме DIRECT (то есть модель была создана с помощью direct_model), the backend will be the optimizer passed to direct_model.
Если JuMP работает в режиме MANUAL или AUTOMATIC, бэкендом является MOI.Utilities.CachingOptimizer.

Чтобы получить индекс переменной или ограничения в модели бэкенда, используйте метод index.

Эту функцию следует использовать только опытным пользователям, которым нужен доступ к низкоуровневым возможностям MathOptInterface или решателя.

Примечания

Если JuMP не находится в режиме DIRECT, тип, возвращаемый backend, может быть разным в зависимости от выпуска JuMP. Поэтому используйте только общедоступный API, предоставляемый MathOptInterface, и не обращайтесь к внутренним полям. Если требуется доступ к самому внутреннему оптимизатору, см. описание метода unsafe_backend. Кроме того, с помощью метода direct_model можно создать модель JuMP в режиме DIRECT.

См. также описание метода unsafe_backend.

Пример

julia> import HiGHS

julia> model = direct_model(HiGHS.Optimizer());

julia> set_silent(model)

julia> @variable(model, x >= 0)
x

julia> highs = backend(model)
A HiGHS model with 1 columns and 0 rows.

julia> index(x)
MOI.VariableIndex(1)

# JuMP.barrier_iterations — Method

barrier_iterations(model::GenericModel)

Если доступно, возвращает совокупное количество итераций барьера во время последней оптимизации (атрибут MOI.BarrierIterations).

Если этот атрибут не реализован решателем, выдает ошибку MOI.GetAttributeNotAllowed.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> optimize!(model)

julia> barrier_iterations(model)
0

# JuMP.bridge_constraints — Method

bridge_constraints(model::GenericModel)

В прямом режиме возвращает значение false.

В ручном или автоматическом режиме возвращает значение типа Bool, указывающее, задан ли оптимизатор и происходит ли автоматическое преобразование неподдерживаемых ограничений в эквивалентные поддерживаемые ограничения, если такое преобразование доступно.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> bridge_constraints(model)
true

julia> model = Model(Ipopt.Optimizer; add_bridges = false);

julia> bridge_constraints(model)
false

# JuMP.build_constraint — Method

build_constraint(error_fn::Function, func, set, args...; kwargs...)

# JuMP.build_variable — Method

build_variable(
    error_fn::Function,
    info::VariableInfo,
    args...;
    kwargs...,
)

Возвращает новый объект AbstractVariable.

Аргументы

error_fn: функция, вызываемая вместо error. error_fn аннотирует сообщение об ошибке дополнительной информацией для пользователя.
info: экземпляр VariableInfo. Имеет ряд полей, связанных с переменной, например info.lower_bound и info.binary.
args: необязательные дополнительные позиционные аргументы для расширения @variable macro.
kwargs: необязательные именованные аргументы для расширения макроса @variable.

См. также описание макроса @variable.

В расширениях должен определяться метод с ОДНИМ позиционным аргументом для диспетчеризации вызова в другой метод. Если у расширения несколько позиционных аргументов, то при их передаче в неправильном порядке возникают ошибки MethodError.

Пример

@variable(model, x, Foo)

вызовет

build_variable(error_fn::Function, info::VariableInfo, ::Type{Foo})

Специальные позиционные аргументы, такие как Bin, Int и PSD, допускается передавать вместе с именованными:

@variable(model, x, Int, Foo(), mykwarg = true)
# или
@variable(model, x, Foo(), Int, mykwarg = true)

вызовет

build_variable(error_fn::Function, info::VariableInfo, ::Foo; mykwarg)

а info.integer будет иметь значение true.

Обратите внимание, что порядок позиционных аргументов не имеет значения.

# JuMP.callback_node_status — Method

callback_node_status(cb_data, model::GenericModel)

Возвращает перечисление MOI.CallbackNodeStatusCode, указывающее, является ли текущее простое решение, доступное из callback_value, целочисленно допустимым.

Пример

julia> import GLPK

julia> model = Model(GLPK.Optimizer);

julia> @variable(model, x <= 10, Int);

julia> @objective(model, Max, x);

julia> function my_callback_function(cb_data)
           status = callback_node_status(cb_data, model)
           println("Status is: ", status)
           return
       end
my_callback_function (generic function with 1 method)

julia> set_attribute(model, GLPK.CallbackFunction(), my_callback_function)

julia> optimize!(model)
Status is: CALLBACK_NODE_STATUS_UNKNOWN
Status is: CALLBACK_NODE_STATUS_UNKNOWN
Status is: CALLBACK_NODE_STATUS_INTEGER
Status is: CALLBACK_NODE_STATUS_INTEGER

# JuMP.callback_value — Method

callback_value(cb_data, x::GenericVariableRef)
callback_value(cb_data, x::Union{GenericAffExpr,GenericQuadExpr})

Возвращает простое решение x внутри обратного вызова.

cb_data — это аргумент функции обратного вызова, а его тип зависит от решателя.

Для проверки доступности решения используйте callback_node_status.

Пример

julia> import GLPK

julia> model = Model(GLPK.Optimizer);

julia> @variable(model, x <= 10, Int);

julia> @objective(model, Max, x);

julia> function my_callback_function(cb_data)
           status = callback_node_status(cb_data, model)
           if status == MOI.CALLBACK_NODE_STATUS_INTEGER
               println("Solution is: ", callback_value(cb_data, x))
           end
           return
       end
my_callback_function (generic function with 1 method)

julia> set_attribute(model, GLPK.CallbackFunction(), my_callback_function)

julia> optimize!(model)
Solution is: 10.0
Solution is: 10.0

# JuMP.check_belongs_to_model — Function

check_belongs_to_model(x::AbstractJuMPScalar, model::AbstractModel)
check_belongs_to_model(x::AbstractConstraint, model::AbstractModel)

Выдает исключение VariableNotOwned, если owner_model для x не является model.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> check_belongs_to_model(x, model)

julia> model_2 = Model();

julia> check_belongs_to_model(x, model_2)
ERROR: VariableNotOwned{VariableRef}(x): the variable x cannot be used in this model because
it belongs to a different model.
[...]

# JuMP.check_belongs_to_model — Method

check_belongs_to_model(con_ref::ConstraintRef, model::AbstractModel)

Выдает исключение ConstraintNotOwned, если owner_model(con_ref) не является model.

# JuMP.coefficient — Method

coefficient(v1::GenericVariableRef{T}, v2::GenericVariableRef{T}) where {T}

Возвращает one(T), если v1 == v2, и zero(T) в противном случае.

Это резервный вариант для других методов coefficient, упрощающий код, в котором выражением может быть отдельная переменная.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> coefficient(x[1], x[1])
1.0

julia> coefficient(x[1], x[2])
0.0

# JuMP.coefficient — Method

coefficient(a::GenericAffExpr{C,V}, v::V) where {C,V}

Возвращает коэффициент, связанный с переменной v в аффинном выражении a.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> expr = 2.0 * x + 1.0;

julia> coefficient(expr, x)
2.0

# JuMP.coefficient — Method

coefficient(a::GenericQuadExpr{C,V}, v1::V, v2::V) where {C,V}

Возвращает коэффициент, связанный с членом v1 * v2 в квадратичном выражении a.

Обратите внимание, что вызов coefficient(a, v1, v2) равносилен coefficient(a, v2, v1).

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> expr = 2.0 * x[1] * x[2];

julia> coefficient(expr, x[1], x[2])
2.0

julia> coefficient(expr, x[2], x[1])
2.0

julia> coefficient(expr, x[1], x[1])
0.0

# JuMP.coefficient — Method

coefficient(a::GenericQuadExpr{C,V}, v::V) where {C,V}

Возвращает коэффициент, связанный с переменной v в аффинном компоненте a.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> expr = 2.0 * x^2 + 3.0 * x;

julia> coefficient(expr, x)
3.0

# JuMP.compute_conflict! — Method

compute_conflict!(model::GenericModel)

Вычисляет конфликт, если модель неразрешима.

Конфликт также называется неприводимой недопустимой подсистемой (IIS).

Если оптимизатор еще не задан (см. описание метода set_optimizer), выдается ошибка NoOptimizer.

Состояние конфликта можно проверить с помощью атрибута модели MOI.ConflictStatus. После этого состояние каждого ограничения можно запросить с помощью атрибута MOI.ConstraintConflictStatus.

См. также описание метода copy_conflict.

Пример

julia> using JuMP

julia> model = Model(Gurobi.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 0);

julia> @constraint(model, c1, x >= 2);

julia> @constraint(model, c2, x <= 1);

julia> optimize!(model)

julia> compute_conflict!(model)

julia> get_attribute(model, MOI.ConflictStatus())
CONFLICT_FOUND::ConflictStatusCode = 3

# JuMP.constant — Method

constant(aff::GenericAffExpr{C,V})::C

Возвращает константу аффинного выражения.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> aff = 2.0 * x + 3.0;

julia> constant(aff)
3.0

# JuMP.constant — Method

constant(quad::GenericQuadExpr{C,V})::C

Возвращает константу квадратичного выражения.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> quad = 2.0 * x^2 + 3.0;

julia> constant(quad)
3.0

# JuMP.constraint_by_name — Function

constraint_by_name(model::AbstractModel, name::String, [F, S])::Union{ConstraintRef,Nothing}

Возвращает ссылку на ограничение с атрибутом имени name или Nothing, если ни у одного ограничения нет такого атрибута имени.

Если несколько ограничений имеют атрибут имени name, выдает ошибку.

Если указаны аргументы F и S, этот метод также выдает ошибку, если ограничение не относится к типу «F в S», где F — это тип JuMP или MOI функции, а S — тип MOI множества.

Указывать F и S рекомендуется в том случае, если типы функции и множества известны, так как может быть выведен возвращаемый тип, в то время как для представленного выше метода (то есть без F и S) точный возвращаемый тип индекса ограничения вывести невозможно.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, con, x^2 == 1)
con : x² = 1

julia> constraint_by_name(model, "kon")

julia> constraint_by_name(model, "con")
con : x² = 1

julia> constraint_by_name(model, "con", AffExpr, MOI.EqualTo{Float64})

julia> constraint_by_name(model, "con", QuadExpr, MOI.EqualTo{Float64})
con : x² = 1

# JuMP.constraint_object — Function

constraint_object(con_ref::ConstraintRef)

Возвращает базовые данные для ограничения, на которое ссылается con_ref.

Пример

Скалярное ограничение:

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, 2x <= 1)
c : 2 x ≤ 1

julia> object = constraint_object(c)
ScalarConstraint{AffExpr, MathOptInterface.LessThan{Float64}}(2 x, MathOptInterface.LessThan{Float64}(1.0))

julia> typeof(object)
ScalarConstraint{AffExpr, MathOptInterface.LessThan{Float64}}

julia> object.func
2 x

julia> object.set
MathOptInterface.LessThan{Float64}(1.0)

Векторное ограничение:

julia> model = Model();

julia> @variable(model, x[1:3]);

julia> @constraint(model, c, x in SecondOrderCone())
c : [x[1], x[2], x[3]] ∈ MathOptInterface.SecondOrderCone(3)

julia> object = constraint_object(c)
VectorConstraint{VariableRef, MathOptInterface.SecondOrderCone, VectorShape}(VariableRef[x[1], x[2], x[3]], MathOptInterface.SecondOrderCone(3), VectorShape())

julia> typeof(object)
VectorConstraint{VariableRef, MathOptInterface.SecondOrderCone, VectorShape}

julia> object.func
3-element Vector{VariableRef}:
 x[1]
 x[2]
 x[3]

julia> object.set
MathOptInterface.SecondOrderCone(3)

# JuMP.constraint_ref_with_index — Method

constraint_ref_with_index(model::AbstractModel, index::MOI.ConstraintIndex)

Возвращает ссылку ConstraintRef модели model, соответствующую index.

Это вспомогательная функция, используемая внутри JuMP и некоторых расширений JuMP. В ее вызове в пользовательском коде потребности возникать не должно.

# JuMP.constraint_string — Method

constraint_string(
    mode::MIME,
    ref::ConstraintRef;
    in_math_mode::Bool = false,
)

Возвращает строковое представление ограничения ref для режима mode.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, 2 * x <= 1);

julia> constraint_string(MIME("text/plain"), c)
"c : 2 x ≤ 1"

# JuMP.constraints_string — Method

constraints_string(mode, model::AbstractModel)::Vector{String}

Возвращает список строк String, описывающих каждое ограничение модели.

Пример

julia> model = Model();

julia> @variable(model, x >= 0);

julia> @constraint(model, c, 2 * x <= 1);

julia> constraints_string(MIME("text/plain"), model)
2-element Vector{String}:
 "c : 2 x ≤ 1"
 "x ≥ 0"

# JuMP.copy_conflict — Method

copy_conflict(model::GenericModel)

Возвращает копию текущего конфликта для модели model и GenericReferenceMap, которую можно использовать для получения ссылки на переменную и ограничение новой модели, соответствующей ссылке на заданную модель model.

Это удобная функция, которая обеспечивает фильтрацию для copy_model.

Примечание

Пример

В следующем примере создается модель model с переменной x и двумя ограничениями: c1 и c2. У этой модели нет решения, так как ограничения являются взаимоисключающими. Решателю предписывается вычислить конфликт с помощью compute_conflict!. Затем части модели model, участвующие в конфликте, копируются в модель iis_model.

julia> using JuMP

julia> import Gurobi

julia> model = Model(Gurobi.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 0)
x

julia> @constraint(model, c1, x >= 2)
c1 : x ≥ 2

julia> @constraint(model, c2, x <= 1)
c2 : x ≤ 1

julia> optimize!(model)

julia> compute_conflict!(model)

julia> if get_attribute(model, MOI.ConflictStatus()) == MOI.CONFLICT_FOUND
           iis_model, reference_map = copy_conflict(model)
           print(iis_model)
       end
Feasibility
Subject to
 c1 : x ≥ 2
 c2 : x ≤ 1

# JuMP.copy_extension_data — Method

copy_extension_data(data, new_model::AbstractModel, model::AbstractModel)

Возвращает копию данных расширения data модели model в данные расширения новой модели new_model.

Для любого расширения JuMP, сохраняющего данные в поле ext, следует добавить метод.

Не занимайтесь «пиратством типов», реализуя этот метод для типов data, которые определены не вами! Расширения JuMP должны сохранять типы, определяемые ими в model.ext, а не обычные типы Julia.

# JuMP.copy_model — Method

copy_model(model::GenericModel; filter_constraints::Union{Nothing, Function}=nothing)

Возвращает копию модели model и GenericReferenceMap, которую можно использовать для получения ссылки на переменную и ограничение новой модели, соответствующей ссылке на заданную модель model. Также реализован метод Base.copy(::AbstractModel); он похож на copy_model, но не возвращает сопоставление ссылок.

Если указан аргумент filter_constraints, копируются только те ограничения, для которых эта функция возвращает true. Этой функции в качестве аргумента передается ссылка на ограничение.

Примечание

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, cref, x == 2)
cref : x = 2

julia> new_model, reference_map = copy_model(model);

julia> x_new = reference_map[x]
x

julia> cref_new = reference_map[cref]
cref : x = 2

# JuMP.delete — Method

delete(model::GenericModel, con_ref::ConstraintRef)

Удаляет ограничение, связанное с constraint_ref, из модели model.

Обратите внимание, что delete не отменяет регистрацию имени в модели, поэтому добавление нового ограничения с тем же именем приведет к ошибке. Чтобы отменить регистрацию удаленного имени, воспользуйтесь методом unregister.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, 2x <= 1)
c : 2 x ≤ 1

julia> delete(model, c)

julia> unregister(model, :c)

julia> print(model)
Feasibility
Subject to

julia> model[:c]
ERROR: KeyError: key :c not found
Stacktrace:
[...]

# JuMP.delete — Method

delete(model::GenericModel, variable_ref::GenericVariableRef)

Удаляет переменную, связанную с variable_ref, из модели model.

Обратите внимание, что delete не отменяет регистрацию имени в модели, поэтому добавление новой переменной с тем же именем приведет к ошибке. Чтобы отменить регистрацию удаленного имени, воспользуйтесь методом unregister.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> delete(model, x)

julia> unregister(model, :x)

julia> print(model)
Feasibility
Subject to

julia> model[:x]
ERROR: KeyError: key :x not found
Stacktrace:
[...]

# JuMP.delete — Method

delete(model::GenericModel, con_refs::Vector{<:ConstraintRef})

Удаляет ограничения, связанные с con_refs, из модели model.

В решателях могут быть реализованы специализированные методы для удаления нескольких ограничений одного конкретного типа. Эти методы могут быть эффективнее, чем многократный вызов метода delete для отдельных ограничений.

См. также описание метода unregister.

Пример

julia> model = Model();

julia> @variable(model, x[1:3]);

julia> @constraint(model, c, 2 * x .<= 1)
3-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, ScalarShape}}:
 c : 2 x[1] ≤ 1
 c : 2 x[2] ≤ 1
 c : 2 x[3] ≤ 1

julia> delete(model, c)

julia> unregister(model, :c)

julia> print(model)
Feasibility
Subject to

julia> model[:c]
ERROR: KeyError: key :c not found
Stacktrace:
[...]

# JuMP.delete — Method

delete(model::GenericModel, variable_refs::Vector{<:GenericVariableRef})

Удаляет переменные, связанные с variable_refs, из модели model. В решателях могут быть реализованы методы для удаления нескольких переменных, которые работают эффективнее, чем многократный вызов метода удаления для отдельных переменных.

См. также описание метода unregister.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> delete(model, x)

julia> unregister(model, :x)

julia> print(model)
Feasibility
Subject to

julia> model[:x]
ERROR: KeyError: key :x not found
Stacktrace:
[...]

# JuMP.delete_lower_bound — Method

delete_lower_bound(v::GenericVariableRef)

Удаляет ограничение нижней границы переменной.

См. также описание LowerBoundRef, has_lower_bound, lower_bound и set_lower_bound.

Пример

julia> model = Model();

julia> @variable(model, x >= 1.0);

julia> has_lower_bound(x)
true

julia> delete_lower_bound(x)

julia> has_lower_bound(x)
false

# JuMP.delete_upper_bound — Method

delete_upper_bound(v::GenericVariableRef)

Удаляет ограничение верхней границы переменной.

Если его не существует, выдает ошибку.

См. также описание UpperBoundRef, has_upper_bound, upper_bound и set_upper_bound.

Пример

julia> model = Model();

julia> @variable(model, x <= 1.0);

julia> has_upper_bound(x)
true

julia> delete_upper_bound(x)

julia> has_upper_bound(x)
false

# JuMP.direct_generic_model — Method

direct_generic_model(
    value_type::Type{T},
    backend::MOI.ModelLike;
) where {T<:Real}

Возвращает новую модель JuMP, используя backend для сохранения модели и ее решения.

В отличие от конструктора Model](api.md#JuMP.Model), кэш модели не хранится вне backend, и мосты не применяются автоматически к [backend.

Примечания

Отсутствие кэша уменьшает объем занимаемой памяти, но важно помнить о следующих последствиях создания моделей в этом прямом режиме.

Если backend не поддерживает операцию, например изменение ограничений или добавление переменных либо ограничений после решения, выдается ошибка. Для моделей, созданных с использованием конструктора Model, в таких ситуациях можно сохранять изменения в кэше и загружать их в оптимизатор при вызове optimize!.
По умолчанию мосты ограничений не поддерживаются.
Используемый оптимизатор нельзя изменить после создания модели.
Созданную модель нельзя скопировать.

# JuMP.direct_generic_model — Method

direct_generic_model(::Type{T}, factory::MOI.OptimizerWithAttributes)

Создает модель direct_generic_model с использованием factory, объекта MOI.OptimizerWithAttributes, созданного с помощью optimizer_with_attributes.

Пример

julia> import HiGHS

julia> optimizer = optimizer_with_attributes(
           HiGHS.Optimizer,
           "presolve" => "off",
           MOI.Silent() => true,
       );

julia> model = direct_generic_model(Float64, optimizer)
A JuMP Model
Feasibility problem with:
Variables: 0
Model mode: DIRECT
Solver name: HiGHS

эквивалентно следующему:

julia> import HiGHS

julia> model = direct_generic_model(Float64, HiGHS.Optimizer())
A JuMP Model
Feasibility problem with:
Variables: 0
Model mode: DIRECT
Solver name: HiGHS

julia> set_attribute(model, "presolve", "off")

julia> set_attribute(model, MOI.Silent(), true)

# JuMP.direct_model — Method

direct_model(backend::MOI.ModelLike)

Возвращает новую модель JuMP, используя backend для сохранения модели и ее решения.

Примечания

Если backend не поддерживает операцию, например изменение ограничений или добавление переменных либо ограничений после решения, выдается ошибка. Для моделей, созданных с использованием конструктора Model, в таких ситуациях можно сохранять изменения в кэше и загружать их в оптимизатор при вызове optimize!.
По умолчанию мосты ограничений не поддерживаются.
Используемый оптимизатор нельзя изменить после создания модели.
Созданную модель нельзя скопировать.

# JuMP.direct_model — Method

direct_model(factory::MOI.OptimizerWithAttributes)

Создает модель direct_model с использованием factory, объекта MOI.OptimizerWithAttributes, созданного с помощью optimizer_with_attributes.

Пример

julia> import HiGHS

julia> optimizer = optimizer_with_attributes(
           HiGHS.Optimizer,
           "presolve" => "off",
           MOI.Silent() => true,
       );

julia> model = direct_model(optimizer)
A JuMP Model
Feasibility problem with:
Variables: 0
Model mode: DIRECT
Solver name: HiGHS

эквивалентно следующему:

julia> import HiGHS

julia> model = direct_model(HiGHS.Optimizer())
A JuMP Model
Feasibility problem with:
Variables: 0
Model mode: DIRECT
Solver name: HiGHS

julia> set_attribute(model, "presolve", "off")

julia> set_attribute(model, MOI.Silent(), true)

# JuMP.drop_zeros! — Method

drop_zeros!(expr::GenericAffExpr)

Удаляет из аффинного выражения члены с коэффициентами 0.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> expr = x[1] + x[2];

julia> add_to_expression!(expr, -1.0, x[1])
0 x[1] + x[2]

julia> drop_zeros!(expr)

julia> expr
x[2]

# JuMP.drop_zeros! — Method

drop_zeros!(expr::GenericQuadExpr)

Удаляет из квадратичного выражения члены с коэффициентами 0.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> expr = x[1]^2 + x[2]^2;

julia> add_to_expression!(expr, -1.0, x[1], x[1])
0 x[1]² + x[2]²

julia> drop_zeros!(expr)

julia> expr
x[2]²

# JuMP.dual — Method

dual(con_ref::ConstraintRef; result::Int = 1)

Возвращает двойственное значение ограничения con_ref, связанное с индексом результата result самого последнего решения, возвращенного решателем.

Чтобы проверить, существует ли результат, прежде чем запрашивать значения, используйте метод has_duals.

См. также описание методов result_count и shadow_price.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x);

julia> @constraint(model, c, x <= 1)
c : x ≤ 1

julia> @objective(model, Max, 2 * x + 1);

julia> optimize!(model)

julia> has_duals(model)
true

julia> dual(c)
-2.0

# JuMP.dual_objective_value — Method

dual_objective_value(model::GenericModel; result::Int = 1)

Возвращает значение цели двойственной задачи, связанное с индексом результата result самого последнего решения, возвращенного решателем.

Если решатель не поддерживает этот атрибут, выдается исключение MOI.UnsupportedAttribute{MOI.DualObjectiveValue}.

Эта функция эквивалентна запросу атрибута MOI.DualObjectiveValue.

См. также описание метода result_count.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 1);

julia> @objective(model, Min, 2 * x + 1);

julia> optimize!(model)

julia> dual_objective_value(model)
3.0

julia> dual_objective_value(model; result = 2)
ERROR: Result index of attribute MathOptInterface.DualObjectiveValue(2) out of bounds. There are currently 1 solution(s) in the model.
Stacktrace:
[...]

# JuMP.dual_shape — Method

dual_shape(shape::AbstractShape)::AbstractShape

Возвращает форму двойственного пространства объектов формы shape. По умолчанию dual_shape для формы — это сама форма. Пример того, когда это правило не соблюдается, см. в разделе примеров ниже.

Пример

Рассмотрим полиномиальные ограничения, для которых двойственными являются ограничения момента, и ограничения момента, для которых двойственными являются полиномиальные ограничения. Формы многочленов можно определить следующим образом:

struct Polynomial
    coefficients::Vector{Float64}
    monomials::Vector{Monomial}
end
struct PolynomialShape <: AbstractShape
    monomials::Vector{Monomial}
end
JuMP.reshape_vector(x::Vector, shape::PolynomialShape) = Polynomial(x, shape.monomials)

А форму моментов можно определить следующим образом:

struct Moments
    coefficients::Vector{Float64}
    monomials::Vector{Monomial}
end
struct MomentsShape <: AbstractShape
    monomials::Vector{Monomial}
end
JuMP.reshape_vector(x::Vector, shape::MomentsShape) = Moments(x, shape.monomials)

Тогда dual_shape позволяет определить форму двойственности полиномиальных ограничений и ограничений момента:

dual_shape(shape::PolynomialShape) = MomentsShape(shape.monomials)
dual_shape(shape::MomentsShape) = PolynomialShape(shape.monomials)

# JuMP.dual_start_value — Method

dual_start_value(con_ref::ConstraintRef)

Возвращает двойственное начальное значение (атрибут MOI ConstraintDualStart) ограничения con_ref.

Если двойственное начальное значение не задано, dual_start_value возвращает nothing.

См. также описание метода set_dual_start_value.

Пример

julia> model = Model();

julia> @variable(model, x, start = 2.0);

julia> @constraint(model, c, [2x] in Nonnegatives())
c : [2 x] ∈ MathOptInterface.Nonnegatives(1)

julia> set_dual_start_value(c, [0.0])

julia> dual_start_value(c)
1-element Vector{Float64}:
 0.0

julia> set_dual_start_value(c, nothing)

julia> dual_start_value(c)

# JuMP.dual_status — Method

dual_status(model::GenericModel; result::Int = 1)

Возвращает объект MOI.ResultStatusCode, описывающий состояние последнего двойственного решения решателя (то есть атрибут MOI.DualStatus), связанного с индексом результата result.

См. также описание метода result_count.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> dual_status(model; result = 2)
NO_SOLUTION::ResultStatusCode = 0

# JuMP.error_if_direct_mode — Method

error_if_direct_mode(model::GenericModel, func::Symbol)

Выдает ошибку, если model находится в прямом режиме во время вызова из функции с именем func.

Используется внутри JuMP или расширениями JuMP, которые не должны поддерживать модели в прямом режиме.

Пример

julia> import HiGHS

julia> model = direct_model(HiGHS.Optimizer());

julia> error_if_direct_mode(model, :foo)
ERROR: The `foo` function is not supported in DIRECT mode.
Stacktrace:
[...]

# JuMP.fix — Method

fix(v::GenericVariableRef, value::Number; force::Bool = false)

Фиксирует значение переменной. Обновляет фиксирующее ограничение, если оно уже имеется; в противном случае создает его.

Если переменная уже имеет границы и force=false, вызов fix приведет к ошибке. Если force=true, существующие границы переменной будут удалены и будет добавлено фиксирующее ограничение. Обратите внимание, что после вызова unfix у переменной не будет границ.

См. также описание FixRef, is_fixed, fix_value и unfix.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> is_fixed(x)
false

julia> fix(x, 1.0)

julia> is_fixed(x)
true

julia> model = Model();

julia> @variable(model, 0 <= x <= 1);

julia> is_fixed(x)
false

julia> fix(x, 1.0; force = true)

julia> is_fixed(x)
true

# JuMP.fix_discrete_variables — Method

fix_discrete_variables([var_value::Function = value,] model::GenericModel)

Изменяет model так, что все двоичные и целочисленные переменные преобразовываются в непрерывные с фиксированными границами var_value(x).

Возвращаемое значение

Возвращает функцию, которую можно вызвать без аргументов для восстановления исходной модели. Если в затронутые переменные вносятся дополнительные изменения, поведение этой функции не определено.

Примечания

При наличии полунепрерывных или полуцелочисленных ограничений возникает ошибка (поддержка таких ограничений может быть добавлена в будущем).
Все остальные ограничения игнорируются (остаются без изменений). Сюда относятся дискретные ограничения, такие как SOS и индикаторные ограничения.

Пример

julia> model = Model();

julia> @variable(model, x, Bin, start = 1);

julia> @variable(model, 1 <= y <= 10, Int, start = 2);

julia> @objective(model, Min, x + y);

julia> undo_relax = fix_discrete_variables(start_value, model);

julia> print(model)
Min x + y
Subject to
 x = 1
 y = 2

julia> undo_relax()

julia> print(model)
Min x + y
Subject to
 y ≥ 1
 y ≤ 10
 y integer
 x binary

# JuMP.fix_value — Method

fix_value(v::GenericVariableRef)

Возвращает значение, на котором фиксируется переменная.

Если его не существует, выдает ошибку.

См. также описание FixRef, is_fixed, fix и unfix.

Пример

julia> model = Model();

julia> @variable(model, x == 1);

julia> fix_value(x)
1.0

# JuMP.flatten! — Method

flatten!(expr::GenericNonlinearExpr)

Удаляет иерархическую структуру нелинейного выражения на месте, поднимая вложенные узлы + и * в одну n-арную операцию.

Мотивация

Нелинейные выражения, созданные с использованием перегрузки операторов, могут иметь глубокую вложенность и быть несбалансированными. Например, prod(x for i in 1:4) создает выражение (x, *(x, *(x, x))) вместо более предпочтительного варианта (x, x, x, x).

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> y = prod(x for i in 1:4)
((x²) * x) * x

julia> flatten!(y)
(x²) * x * x

julia> flatten!(sin(prod(x for i in 1:4)))
sin((x²) * x * x)

# JuMP.function_string — Method

function_string(
    mode::MIME,
    func::Union{JuMP.AbstractJuMPScalar,Vector{<:JuMP.AbstractJuMPScalar}},
)

Возвращает строку String, представляющую функцию func, используя режим вывода mode.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> function_string(MIME("text/plain"), 2 * x + 1)
"2 x + 1"

# JuMP.get_attribute — Method

get_attribute(model::GenericModel, attr::MOI.AbstractModelAttribute)
get_attribute(x::GenericVariableRef, attr::MOI.AbstractVariableAttribute)
get_attribute(cr::ConstraintRef, attr::MOI.AbstractConstraintAttribute)

Возвращает значение относящегося к решателю атрибута attr.

Эквивалентно вызову MOI.get](api.md#MathOptInterface.get-Tuple{GenericModel, MathOptInterface.AbstractModelAttribute}) с соответствующей моделью MOI, а для переменных и ограничений — с соответствующим индексом MOI.VariableIndex или [MOI.ConstraintIndex.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, c, 2 * x <= 1)
c : 2 x ≤ 1

julia> get_attribute(model, MOI.Name())
""

julia> get_attribute(x, MOI.VariableName())
"x"

julia> get_attribute(c, MOI.ConstraintName())
"c"

# JuMP.get_attribute — Method

get_attribute(
    model::Union{GenericModel,MOI.OptimizerWithAttributes},
    attr::Union{AbstractString,MOI.AbstractOptimizerAttribute},
)

Возвращает значение относящегося к решателю атрибута attr.

Эквивалентно вызову MOI.get с соответствующей моделью MOI.

Если attr — это строка AbstractString, она преобразуется в MOI.RawOptimizerAttribute.

Пример

julia> import HiGHS

julia> opt = optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => true);

julia> model = Model(opt);

julia> get_attribute(model, "output_flag")
true

julia> get_attribute(model, MOI.RawOptimizerAttribute("output_flag"))
true

julia> get_attribute(opt, "output_flag")
true

julia> get_attribute(opt, MOI.RawOptimizerAttribute("output_flag"))
true

# JuMP.get_optimizer_attribute — Method

get_optimizer_attribute(
    model::Union{GenericModel,MOI.OptimizerWithAttributes},
    attr::Union{AbstractString,MOI.AbstractOptimizerAttribute},
)

Возвращает значение, связанное с относящимся к решателю атрибутом attr.

Если attr — это строка AbstractString, данный метод эквивалентен вызову get_optimizer_attribute(model, MOI.RawOptimizerAttribute(name)).

Совместимость

Этот метод сохранится во всех выпусках JuMP v1.X, но может быть удален в будущем выпуске v2.0. Вместо него рекомендуется использовать get_attribute.

См. также описание методов set_optimizer_attribute и set_optimizer_attributes.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> get_optimizer_attribute(model, MOI.Silent())
false

# JuMP.has_duals — Method

has_duals(model::GenericModel; result::Int = 1)

Возвращает true, если решатель имеет двойственное решение по индексу результата result, доступному для запроса; в противном случае возвращает false.

См. также описание dual, shadow_price и result_count.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x);

julia> @constraint(model, c, x <= 1)
c : x ≤ 1

julia> @objective(model, Max, 2 * x + 1);

julia> has_duals(model)
false

julia> optimize!(model)

julia> has_duals(model)
true

# JuMP.has_lower_bound — Method

has_lower_bound(v::GenericVariableRef)

Возвращает значение true, если у v есть нижняя граница. При значении true нижнюю границу можно запросить с помощью метода lower_bound.

См. также описание LowerBoundRef, lower_bound, set_lower_bound и delete_lower_bound.

Пример

julia> model = Model();

julia> @variable(model, x >= 1.0);

julia> has_lower_bound(x)
true

# JuMP.has_start_value — Method

has_start_value(variable::AbstractVariableRef)

Возвращает значение true, если для переменной задано начальное значение; в противном случае возвращает false.

См. также описание методов start_value и set_start_value.

Пример

julia> model = Model();

julia> @variable(model, x, start = 1.5);

julia> @variable(model, y);

julia> has_start_value(x)
true

julia> has_start_value(y)
false

julia> start_value(x)
1.5

julia> set_start_value(y, 2.0)

julia> has_start_value(y)
true

julia> start_value(y)
2.0

# JuMP.has_upper_bound — Method

has_upper_bound(v::GenericVariableRef)

Возвращает значение true, если у v есть верхняя граница. При значении true верхнюю границу можно запросить с помощью метода upper_bound.

См. также описание UpperBoundRef, upper_bound, set_upper_bound и delete_upper_bound.

Пример

julia> model = Model();

julia> @variable(model, x <= 1.0);

julia> has_upper_bound(x)
true

# JuMP.has_values — Method

has_values(model::GenericModel; result::Int = 1)

Возвращает true, если решатель имеет прямое решение по индексу результата result, доступному для запроса; в противном случае возвращает false.

См. также описание методов value и result_count.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x);

julia> @constraint(model, c, x <= 1)
c : x ≤ 1

julia> @objective(model, Max, 2 * x + 1);

julia> has_values(model)
false

julia> optimize!(model)

julia> has_values(model)
true

# JuMP.in_set_string — Function

in_set_string(mode::MIME, set)

Возвращает строку String, представляющую принадлежность множеству set, используя режим вывода mode.

Расширения

Расширения JuMP могут расширять этот метод для новых типов set, чтобы улучшить удобочитаемость выводимых данных.

Пример

julia> in_set_string(MIME("text/plain"), MOI.Interval(1.0, 2.0))
"∈ [1, 2]"

# JuMP.in_set_string — Method

in_set_string(mode::MIME, constraint::AbstractConstraint)

Возвращает строку String, представляющую принадлежность множеству ограничения constraint, используя режим вывода mode.

# JuMP.index — Method

index(cr::ConstraintRef)::MOI.ConstraintIndex

Возвращает индекс ограничения, соответствующего cr в бэкенде MOI.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, x >= 0);

julia> index(c)
MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}(1)

# JuMP.index — Method

index(v::GenericVariableRef)::MOI.VariableIndex

Возвращает индекс переменной, соответствующей v в бэкенде MOI.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> index(x)
MOI.VariableIndex(1)

# JuMP.is_binary — Method

is_binary(v::GenericVariableRef)

Возвращает значение true, если переменная v ограничена двоичной формой.

См. также описание BinaryRef, set_binary и unset_binary.

Пример

julia> model = Model();

julia> @variable(model, x, Bin);

julia> is_binary(x)
true

# JuMP.is_fixed — Method

is_fixed(v::GenericVariableRef)

Возвращает значение true, если v — это фиксированная переменная. При значении true фиксированное значение можно запросить с помощью метода fix_value.

См. также описание FixRef, fix_value, fix и unfix.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> is_fixed(x)
false

julia> fix(x, 1.0)

julia> is_fixed(x)
true

# JuMP.is_integer — Method

is_integer(v::GenericVariableRef)

Возвращает значение true, если переменная v ограничена целочисленной формой.

См. также описание IntegerRef, set_integer и unset_integer.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> is_integer(x)
false

julia> set_integer(x)

julia> is_integer(x)
true

# JuMP.is_parameter — Method

is_parameter(x::GenericVariableRef)::Bool

Возвращает значение true, если x должно быть параметром.

См. также описание ParameterRef, set_parameter_value и parameter_value.

Пример

julia> model = Model();

julia> @variable(model, p in Parameter(2))
p

julia> is_parameter(p)
true

julia> @variable(model, x)
x

julia> is_parameter(x)
false

# JuMP.is_solved_and_feasible — Method

is_solved_and_feasible(
    model::GenericModel;
    allow_local::Bool = true,
    allow_almost::Bool = false,
    dual::Bool = false,
    result::Int = 1,
)

Возвращает значение true, если модель имеет допустимое прямое решение, связанное с индексом результата result, а termination_status имеет значение OPTIMAL (решатель нашел глобальный оптимум) или LOCALLY_SOLVED (решатель нашел локальный оптимум, который также может быть глобальным, однако доказать это решателю не удалось).

При allow_local = false данная функция возвращает значение true только в том случае, если termination_status имеет значение OPTIMAL.

При allow_almost = true метод termination_status может также возвращать значение ALMOST_OPTIMAL или ALMOST_LOCALLY_SOLVED (при allow_local), а методы primal_status и dual_status могут также возвращать значение NEARLY_FEASIBLE_POINT.

Если аргумент dual имеет значение true, дополнительно проверяется наличие оптимального двойственного решения.

Если эта функция возвращает значение false, используйте методы termination_status, result_count, primal_status и dual_status для определения имеющихся решений (если они есть).

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> is_solved_and_feasible(model)
false

# JuMP.is_valid — Method

is_valid(model::GenericModel, con_ref::ConstraintRef{<:AbstractModel})

Возвращает значение true, если con_ref ссылается на допустимое ограничение в model.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, 2 * x <= 1);

julia> is_valid(model, c)
true

julia> model_2 = Model();

julia> is_valid(model_2, c)
false

# JuMP.is_valid — Method

is_valid(model::GenericModel, variable_ref::GenericVariableRef)

Возвращает значение true, если variable ссылается на допустимую переменную в model.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> is_valid(model, x)
true

julia> model_2 = Model();

julia> is_valid(model_2, x)
false

# JuMP.isequal_canonical — Function

isequal_canonical(
    x::T,
    y::T
) where {T<:AbstractJuMPScalar,AbstractArray{<:AbstractJuMPScalar}}

Возвращает значение true, если x равно y после исключения нолей и без учета порядка.

Этот метод в основном полезен для тестирования, поскольку резервные варианты, такие как x == y, не учитывают допустимые математические сравнения, например x[1] + 0 x[2] + 1 == x[1] + 1.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> a = x[1] + 1.0
x[1] + 1

julia> b = x[1] + x[2] + 1.0
x[1] + x[2] + 1

julia> add_to_expression!(b, -1.0, x[2])
x[1] + 0 x[2] + 1

julia> a == b
false

julia> isequal_canonical(a, b)
true

# JuMP.jump_function — Function

jump_function(model::AbstractModel, x::MOI.AbstractFunction)

Для заданного объекта MathOptInterface x возвращает эквивалент JuMP.

См. также описание функции moi_function.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> f = 2.0 * index(x) + 1.0
1.0 + 2.0 MOI.VariableIndex(1)

julia> jump_function(model, f)
2 x + 1

# JuMP.jump_function — Method

jump_function(constraint::AbstractConstraint)

Возвращает функцию ограничения constraint в форме «функция во множестве» в виде AbstractJuMPScalar или Vector{AbstractJuMPScalar}.

# JuMP.jump_function_type — Function

jump_function_type(model::AbstractModel, ::Type{T}) where {T}

Для заданного типа объекта MathOptInterface T возвращает эквивалент JuMP.

См. также описание функции moi_function_type.

Пример

julia> model = Model();

julia> jump_function_type(model, MOI.ScalarAffineFunction{Float64})
AffExpr (alias for GenericAffExpr{Float64, GenericVariableRef{Float64}})

# JuMP.latex_formulation — Method

latex_formulation(model::AbstractModel)

Заключает модель model в тип, что позволяет выводить ее в отформатированном виде как text/latex в записной книжке, например IJulia, или в Documenter.

Для вывода модели следует заканчивать ячейку вызовом latex_formulation(model) или вызывать display(latex_formulation(model)) для отображения модели изнутри функции.

# JuMP.linear_terms — Method

linear_terms(aff::GenericAffExpr{C,V})

Предоставляет итератор по кортежам коэффициентов и переменных (a_i::C, x_i::V) в линейной части аффинного выражения.

# JuMP.linear_terms — Method

linear_terms(quad::GenericQuadExpr{C,V})

Предоставляет итератор по кортежам (coefficient::C, variable::V) в линейной части квадратичного выражения.

# JuMP.list_of_constraint_types — Method

list_of_constraint_types(model::GenericModel)::Vector{Tuple{Type,Type}}

Возвращает список кортежей вида (F, S), где F — тип функции JuMP, а S — тип множества MOI такой, что all_constraints(model, F, S) возвращает непустой список.

Пример

julia> model = Model();

julia> @variable(model, x >= 0, Bin);

julia> @constraint(model, 2x <= 1);

julia> list_of_constraint_types(model)
3-element Vector{Tuple{Type, Type}}:
 (AffExpr, MathOptInterface.LessThan{Float64})
 (VariableRef, MathOptInterface.GreaterThan{Float64})
 (VariableRef, MathOptInterface.ZeroOne)

Замечания по производительности

Итерация по списку типов функций и множеств является нестабильной по типу операцией. Можно прибегнуть к функциональному барьеру. Дополнительные сведения см. в разделе Performance tips for extensions документации.

# JuMP.lower_bound — Method

lower_bound(v::GenericVariableRef)

Возвращает нижнюю границу переменной. Если ее не существует, выдает ошибку.

См. также описание LowerBoundRef, has_lower_bound, set_lower_bound и delete_lower_bound.

Пример

julia> model = Model();

julia> @variable(model, x >= 1.0);

julia> lower_bound(x)
1.0

# JuMP.lp_matrix_data — Method

lp_matrix_data(model::GenericModel{T})

Для данной модели JuMP линейной программы возвращает структуру LPMatrixData{T}, в которой хранятся данные для эквивалентной линейной программы в следующей форме:

где элементы x могут быть непрерывными, целочисленными или двоичными переменными.

Поля

Структура, возвращаемая методом lp_matrix_data, имеет следующие поля.

A::SparseArrays.SparseMatrixCSC{T,Int}: матрица ограничений в форме разреженной матрицы.
b_lower::Vector{T}: плотный вектор нижних границ строк. При отсутствии используется значение typemin(T).
b_upper::Vector{T}: плотный вектор верхних границ строк. При отсутствии используется значение typemax(T).
x_lower::Vector{T}: плотный вектор нижних границ переменных. При отсутствии используется значение typemin(T).
x_upper::Vector{T}: плотный вектор верхних границ переменных. При отсутствии используется значение typemax(T).
c::Vector{T}: плотный вектор коэффициентов линейной целевой функции.
c_offset::T: свободный член целевой функции.
sense::MOI.OptimizationSense: целевое назначение модели.
integers::Vector{Int}: отсортированный список индексов столбцов, являющихся целочисленными переменными.
binaries::Vector{Int}: отсортированный список индексов столбцов, являющихся двоичными переменными.
variables::Vector{GenericVariableRef{T}}: вектор GenericVariableRef, соответствующий порядку столбцов в матричной форме.
affine_constraints::Vector{ConstraintRef}: вектор ConstraintRef, соответствующий порядку строк в матричной форме.

Ограничения

Модели, поддерживаемые lp_matrix_data, намеренно ограничены линейными программами.

Пример

julia> model = Model();

julia> @variable(model, x[1:2] >= 0);

julia> @constraint(model, x[1] + 2 * x[2] <= 1);

julia> @objective(model, Max, x[2]);

julia> data = lp_matrix_data(model);

julia> data.A
1×2 SparseArrays.SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 1.0  2.0

julia> data.b_lower
1-element Vector{Float64}:
 -Inf

julia> data.b_upper
1-element Vector{Float64}:
 1.0

julia> data.x_lower
2-element Vector{Float64}:
 0.0
 0.0

julia> data.x_upper
2-element Vector{Float64}:
 Inf
 Inf

julia> data.c
2-element Vector{Float64}:
 0.0
 1.0

julia> data.c_offset
0.0

julia> data.sense
MAX_SENSE::OptimizationSense = 1

# JuMP.lp_sensitivity_report — Method

lp_sensitivity_report(model::GenericModel{T}; atol::T = Base.rtoldefault(T))::SensitivityReport{T} where {T}

Для данной линейной программы model с текущим оптимальным базисом возвращает объект SensitivityReport, который сопоставляет следующее:

каждую ссылку на переменную с кортежем (d_lo, d_hi)::Tuple{T,T}, объясняя, насколько может измениться целевой коэффициент соответствующей переменной так, чтобы исходный базис оставался оптимальным;
каждую ссылку на ограничение с кортежем (d_lo, d_hi)::Tuple{T,T}, объясняя, насколько может измениться правая часть соответствующего ограничения так, чтобы базис оставался оптимальным.

Оба кортежа являются относительными, а не абсолютными. Таким образом, если заданы целевой коэффициент 1.0 и кортеж (-0.5, 0.5), целевой коэффициент может находиться в диапазоне от 1.0 - 0.5 до 1.0 + 0.5.

atol — это допуск прямо-двойственной оптимальности, который должен соответствовать допуску решателя, используемого для вычисления базиса.

Обратите внимание: интервальные ограничения НЕ поддерживаются.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, -1 <= x <= 2)
x

julia> @objective(model, Min, x)
x

julia> optimize!(model)

julia> report = lp_sensitivity_report(model; atol = 1e-7);

julia> dx_lo, dx_hi = report[x]
(-1.0, Inf)

julia> println(
           "The objective coefficient of `x` can decrease by $dx_lo or " *
           "increase by $dx_hi."
       )
The objective coefficient of `x` can decrease by -1.0 or increase by Inf.

julia> dRHS_lo, dRHS_hi = report[LowerBoundRef(x)]
(-Inf, 3.0)

julia> println(
           "The lower bound of `x` can decrease by $dRHS_lo or increase " *
           "by $dRHS_hi."
       )
The lower bound of `x` can decrease by -Inf or increase by 3.0.

# JuMP.map_coefficients — Method

map_coefficients(f::Function, a::GenericAffExpr)

Применяет функцию f к коэффициентам и свободному члену выражения GenericAffExpr a и возвращает новое выражение.

См. также описание метода map_coefficients_inplace!.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> a = GenericAffExpr(1.0, x => 1.0)
x + 1

julia> map_coefficients(c -> 2 * c, a)
2 x + 2

julia> a
x + 1

# JuMP.map_coefficients — Method

map_coefficients(f::Function, a::GenericQuadExpr)

Применяет функцию f к коэффициентам и свободному члену выражения GenericQuadExpr a и возвращает новое выражение.

См. также описание метода map_coefficients_inplace!.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> a = @expression(model, x^2 + x + 1)
x² + x + 1

julia> map_coefficients(c -> 2 * c, a)
2 x² + 2 x + 2

julia> a
x² + x + 1

# JuMP.map_coefficients_inplace! — Method

map_coefficients_inplace!(f::Function, a::GenericAffExpr)

Применяет функцию f к коэффициентам и свободному члену выражения GenericAffExpr a и обновляет их на месте.

См. также описание метода map_coefficients.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> a = GenericAffExpr(1.0, x => 1.0)
x + 1

julia> map_coefficients_inplace!(c -> 2 * c, a)
2 x + 2

julia> a
2 x + 2

# JuMP.map_coefficients_inplace! — Method

map_coefficients_inplace!(f::Function, a::GenericQuadExpr)

Применяет функцию f к коэффициентам и свободному члену выражения GenericQuadExpr a и обновляет их на месте.

См. также описание метода map_coefficients.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> a = @expression(model, x^2 + x + 1)
x² + x + 1

julia> map_coefficients_inplace!(c -> 2 * c, a)
2 x² + 2 x + 2

julia> a
2 x² + 2 x + 2

# JuMP.mode — Method

mode(model::GenericModel)

Возвращает ModelMode для модели model.

Пример

julia> model = Model();

julia> mode(model)
AUTOMATIC::ModelMode = 0

# JuMP.model_convert — Method

model_convert(
    model::AbstractModel,
    rhs::Union{
        AbstractConstraint,
        Number,
        AbstractJuMPScalar,
        MOI.AbstractSet,
    },
)

Преобразует коэффициенты и константы функций и множеств в rhs в тип коэффициентов value_type(typeof(model)).

Назначение

Создание и добавление ограничения — это двухэтапный процесс. На первом этапе вызывается build_constraint, и результат передается в add_constraint.

Однако, поскольку метод build_constraint не принимает model в качестве аргумента, коэффициенты и константы функции или набора могут отличаться от value_type(typeof(model)).

Поэтому результат build_constraint преобразуется в вызове model_convert, прежде чем результат будет передан в add_constraint.

# JuMP.model_string — Method

model_string(mode::MIME, model::AbstractModel)

Возвращает представление model в виде String для режима mode.

Пример

julia> model = Model();

julia> @variable(model, x >= 0);

julia> print(model_string(MIME("text/plain"), model))
Feasibility
Subject to
 x ≥ 0

# JuMP.moi_function — Function

moi_function(x::AbstractJuMPScalar)
moi_function(x::AbstractArray{<:AbstractJuMPScalar})

Для данного объекта JuMP x возвращает эквивалент MathOptInterface.

См. также описание функции jump_function.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> f = 2.0 * x + 1.0
2 x + 1

julia> moi_function(f)
1.0 + 2.0 MOI.VariableIndex(1)

# JuMP.moi_function — Method

moi_function(constraint::AbstractConstraint)

Возвращает функцию ограничения constraint в форме «функция во множестве» в виде MathOptInterface.AbstractFunction.

# JuMP.moi_function_type — Function

moi_function_type(::Type{T}) where {T}

Для данного типа объекта JuMP T возвращает эквивалент MathOptInterface.

См. также описание функции jump_function_type.

Пример

julia> moi_function_type(AffExpr)
MathOptInterface.ScalarAffineFunction{Float64}

# JuMP.moi_set — Method

moi_set(constraint::AbstractConstraint)

Возвращает множество ограничения constraint в форме «функция во множестве» в виде MathOptInterface.AbstractSet.

moi_set(s::AbstractVectorSet, dim::Int)

Возвращает множество MOI размерности dim, соответствующее множеству JuMP s.

moi_set(s::AbstractScalarSet)

Возвращает множество MOI, соответствующее множеству JuMP s.

# JuMP.name — Method

name(model::AbstractModel)

Возвращает атрибут MOI.Name бэкенда backend модели model или значение по умолчанию, если он пуст.

Пример

julia> model = Model();

julia> name(model)
"A JuMP Model"

# JuMP.name — Method

name(v::GenericVariableRef)::String

Возвращает атрибут имени переменной.

Пример

julia> model = Model();

julia> @variable(model, x[1:2])
2-element Vector{VariableRef}:
 x[1]
 x[2]

julia> name(x[1])
"x[1]"

# JuMP.name — Method

name(con_ref::ConstraintRef)

Возвращает атрибут имени ограничения.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, [2x] in Nonnegatives())
c : [2 x] ∈ MathOptInterface.Nonnegatives(1)

julia> name(c)
"c"

# JuMP.node_count — Method

node_count(model::GenericModel)

Возвращает общее количество узлов дерева ветвей и границ, исследованных во время последней оптимизации в частично целочисленной программе (атрибут MOI.NodeCount), если доступно.

Если этот атрибут не реализован решателем, выдает ошибку MOI.GetAttributeNotAllowed.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> optimize!(model)

julia> node_count(model)
0

# JuMP.nonlinear_constraint_string — Method

nonlinear_constraint_string(
    model::GenericModel,
    mode::MIME,
    c::_NonlinearConstraint,
)

Возвращает строковое представление нелинейного ограничения c, принадлежащего model, для режима mode.

Совместимость

# JuMP.nonlinear_dual_start_value — Method

nonlinear_dual_start_value(model::Model)

Возвращает текущее значение атрибута MOI MOI.NLPBlockDualStart.

Совместимость

# JuMP.nonlinear_expr_string — Method

nonlinear_expr_string(
    model::GenericModel,
    mode::MIME,
    c::MOI.Nonlinear.Expression,
)

Возвращает строковое представление нелинейного выражения c, принадлежащего model, для режима mode.

Совместимость

# JuMP.nonlinear_model — Method

nonlinear_model(
    model::GenericModel;
    force::Bool = false,
)::Union{MOI.Nonlinear.Model,Nothing}

Если model имеет нелинейные компоненты, возвращает MOI.Nonlinear.Model; в противном случае возвращает nothing.

Если force имеет значение true, всегда возвращается объект MOI.Nonlinear.Model, а если для модели его не существует, создается пустой такой объект.

Совместимость

# JuMP.normalized_coefficient — Method

normalized_coefficient(
    constraint::ConstraintRef,
    variable_1::GenericVariableRef,
    variable_2::GenericVariableRef,
)

Возвращает квадратичный коэффициент, связанный с variable_1 и variable_2 в ограничении constraint, которое было нормализовано JuMP в стандартную форму.

См. также описание метода set_normalized_coefficient.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> @constraint(model, con, 2x[1]^2 + 3 * x[1] * x[2] + x[2] <= 2)
con : 2 x[1]² + 3 x[1]*x[2] + x[2] ≤ 2

julia> normalized_coefficient(con, x[1], x[1])
2.0

julia> normalized_coefficient(con, x[1], x[2])
3.0

julia> @constraint(model, con_vec, x.^2 <= [1, 2])
con_vec : [x[1]² - 1, x[2]² - 2] ∈ MathOptInterface.Nonpositives(2)

julia> normalized_coefficient(con_vec, x[1], x[1])
1-element Vector{Tuple{Int64, Float64}}:
 (1, 1.0)

julia> normalized_coefficient(con_vec, x[1], x[2])
Tuple{Int64, Float64}[]

# JuMP.normalized_coefficient — Method

normalized_coefficient(
    constraint::ConstraintRef,
    variable::GenericVariableRef,
)

Возвращает коэффициент, связанный с variable в ограничении constraint, которое было нормализовано JuMP в стандартную форму.

См. также описание метода set_normalized_coefficient.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, con, 2x + 3x <= 2)
con : 5 x ≤ 2

julia> normalized_coefficient(con, x)
5.0

julia> @constraint(model, con_vec, [x, 2x + 1, 3] >= 0)
con_vec : [x, 2 x + 1, 3] ∈ MathOptInterface.Nonnegatives(3)

julia> normalized_coefficient(con_vec, x)
2-element Vector{Tuple{Int64, Float64}}:
 (1, 1.0)
 (2, 2.0)

# JuMP.normalized_rhs — Method

normalized_rhs(constraint::ConstraintRef)

Возвращает член из правой части ограничения constraint, которое было преобразовано JuMP в нормализованную форму.

См. также описание метода set_normalized_rhs.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, con, 2x + 1 <= 2)
con : 2 x ≤ 1

julia> normalized_rhs(con)
1.0

# JuMP.num_constraints — Method

num_constraints(model::GenericModel, function_type, set_type)::Int64

Возвращает количество ограничений, которые в настоящее время имеются в модели, где функция имеет тип function_type, а множество — тип set_type.

См. также описание методов list_of_constraint_types и all_constraints.

Пример

julia> model = Model();

julia> @variable(model, x >= 0, Bin);

julia> @variable(model, y);

julia> @constraint(model, y in MOI.GreaterThan(1.0));

julia> @constraint(model, y <= 1.0);

julia> @constraint(model, 2x <= 1);

julia> num_constraints(model, VariableRef, MOI.GreaterThan{Float64})
2

julia> num_constraints(model, VariableRef, MOI.ZeroOne)
1

julia> num_constraints(model, AffExpr, MOI.LessThan{Float64})
2

# JuMP.num_constraints — Method

num_constraints(model::GenericModel; count_variable_in_set_constraints::Bool)

Возвращает количество ограничений в model.

При count_variable_in_set_constraints == true включаются ограничения VariableRef, такие как «VariableRef в Integer». Чтобы подсчитывались только структурные ограничения (например, строки в матрице ограничений линейной программы), передайте count_variable_in_set_constraints = false.

Пример

julia> model = Model();

julia> @variable(model, x >= 0, Int);

julia> @constraint(model, 2x <= 1);

julia> num_constraints(model; count_variable_in_set_constraints = true)
3

julia> num_constraints(model; count_variable_in_set_constraints = false)
1

# JuMP.num_nonlinear_constraints — Method

num_nonlinear_constraints(model::GenericModel)

Возвращает количество нелинейных ограничений, связанных с model.

Совместимость

Эта функция подсчитывает только те ограничения, которые были добавлены с помощью @NLconstraint и add_nonlinear_constraint. Она не подсчитывает ограничения GenericNonlinearExpr.

# JuMP.num_variables — Method

num_variables(model::GenericModel)::Int64

Возвращает количество переменных в model.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> num_variables(model)
2

# JuMP.object_dictionary — Method

object_dictionary(model::GenericModel)

Возвращает словарь, в котором символьное имя переменной, ограничения или выражения сопоставляется с соответствующим объектом.

Объекты связываются с определенными символами в макросах. Например, @variable(model, x[1:2, 1:2]) связывает массив переменных x с символом :x.

Этот метод должен быть определен для любого подтипа AbstractModel.

См. также описание метода unregister.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> object_dictionary(model)
Dict{Symbol, Any} with 1 entry:
  :x => VariableRef[x[1], x[2]]

# JuMP.objective_bound — Method

objective_bound(model::GenericModel)

Возвращает лучшую из известных границ оптимального целевого значения после вызова optimize!(model).

Для целевых функций со скалярным значением эта функция возвращает Float64. Для целевых функций с векторным значением она возвращает Vector{Float64}.

В случае целевой функции с векторным значением возвращается идеальная точка, то есть точка, полученная при независимой оптимизации каждой целевой функции.

Эта функция эквивалентна запросу атрибута MOI.ObjectiveBound.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 1, Int);

julia> @objective(model, Min, 2 * x + 1);

julia> optimize!(model)

julia> objective_bound(model)
3.0

# JuMP.objective_function — Method

objective_function(
    model::GenericModel,
    ::Type{F} = objective_function_type(model),
) where {F}

Возвращает объект типа F, представляющий целевую функцию.

Выдает ошибку, если целевую функцию невозможно преобразовать в тип F.

Эта функция эквивалентна запросу атрибута MOI.ObjectiveFunction{F}.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @objective(model, Min, 2x + 1)
2 x + 1

julia> objective_function(model, AffExpr)
2 x + 1

julia> objective_function(model, QuadExpr)
2 x + 1

julia> typeof(objective_function(model, QuadExpr))
QuadExpr (alias for GenericQuadExpr{Float64, GenericVariableRef{Float64}})

Из последних двух команд видно, что даже если целевая функция является аффинной, ее можно запросить как квадратичную функцию, так как она может быть преобразована в нее, и результат будет квадратичным.

Однако ее невозможно преобразовать в переменную:

julia> objective_function(model, VariableRef)
ERROR: InexactError: convert(MathOptInterface.VariableIndex, 1.0 + 2.0 MOI.VariableIndex(1))
[...]

# JuMP.objective_function_string — Method

objective_function_string(mode, model::AbstractModel)::String

Возвращает строку String, описывающую целевую функцию модели.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @objective(model, Min, 2 * x);

julia> objective_function_string(MIME("text/plain"), model)
"2 x"

# JuMP.objective_function_type — Method

objective_function_type(model::GenericModel)::AbstractJuMPScalar

Возвращает тип целевой функции.

Эта функция эквивалентна запросу атрибута MOI.ObjectiveFunctionType.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @objective(model, Min, 2 * x + 1);

julia> objective_function_type(model)
AffExpr (alias for GenericAffExpr{Float64, GenericVariableRef{Float64}})

# JuMP.objective_sense — Method

objective_sense(model::GenericModel)::MOI.OptimizationSense

Возвращает целевое назначение.

Эта функция эквивалентна запросу атрибута MOI.ObjectiveSense.

Пример

julia> model = Model();

julia> objective_sense(model)
FEASIBILITY_SENSE::OptimizationSense = 2

julia> @variable(model, x);

julia> @objective(model, Max, x)
x

julia> objective_sense(model)
MAX_SENSE::OptimizationSense = 1

# JuMP.objective_value — Method

objective_value(model::GenericModel; result::Int = 1)

Возвращает целевое значение, связанное с индексом результата result самого последнего решения, возвращенного решателем.

Эта функция эквивалентна запросу атрибута MOI.ObjectiveValue.

См. также описание метода result_count.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 1);

julia> @objective(model, Min, 2 * x + 1);

julia> optimize!(model)

julia> objective_value(model)
3.0

julia> objective_value(model; result = 2)
ERROR: Result index of attribute MathOptInterface.ObjectiveValue(2) out of bounds. There are currently 1 solution(s) in the model.
Stacktrace:
[...]

# JuMP.op_ifelse — Method

op_ifelse(a, x, y)

Функция, по умолчанию равная ifelse(a, x, y), но при вызове с переменными или выражением JuMP в первом аргументе возвращающая GenericNonlinearExpr.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> op_ifelse(true, 1.0, 2.0)
1.0

julia> op_ifelse(x, 1.0, 2.0)
ifelse(x, 1.0, 2.0)

julia> op_ifelse(true, x, 2.0)
x

# JuMP.op_string — Method

op_string(mime::MIME, x::GenericNonlinearExpr, ::Val{op}) where {op}

Возвращает строку, которая должна быть выведена для оператора op при вызове function_string с mime и x.

Пример

julia> model = Model();

julia> @variable(model, x[1:2], Bin);

julia> f = @expression(model, x[1] || x[2]);

julia> op_string(MIME("text/plain"), f, Val(:||))
"||"

# JuMP.operator_to_set — Method

operator_to_set(error_fn::Function, ::Val{sense_symbol})

Преобразует символ назначения во множество set так, что @constraint(model, func sense_symbol 0) эквивалентно @constraint(model, func in set) для любого func::AbstractJuMPScalar.

Пример

После определения пользовательского множества можно напрямую создать ограничение JuMP с ним:

julia> struct CustomSet{T} <: MOI.AbstractScalarSet
           value::T
       end

julia> Base.copy(x::CustomSet) = CustomSet(x.value)

julia> model = Model();

julia> @variable(model, x)
x

julia> cref = @constraint(model, x in CustomSet(1.0))
x ∈ CustomSet{Float64}(1.0)

Однако может существовать подходящий знак, который можно использовать для обеспечения более удобного синтаксиса:

julia> JuMP.operator_to_set(::Function, ::Val{:⊰}) = CustomSet(0.0)

julia> MOIU.supports_shift_constant(::Type{<:CustomSet}) = true

julia> MOIU.shift_constant(set::CustomSet, value) = CustomSet(set.value + value)

julia> cref = @constraint(model, x ⊰ 1)
x ∈ CustomSet{Float64}(1.0)

Обратите внимание, что сначала вся функция переносится в правую часть, а затем знак преобразуется во множество с нулевой константой, и, наконец, константа переносится во множество с помощью MOIU.shift_constant.

# JuMP.operator_warn — Method

operator_warn(model::AbstractModel)
operator_warn(model::GenericModel)

Эта функция вызывается для модели всякий раз, когда два аффинных выражения складываются без использования destructive_add! и по крайней мере одно из них содержит более 50 членов.

В случае Model, если эта функция вызывается более 20 000 раз, предупреждение генерируется один раз.

# JuMP.optimize! — Method

optimize!(
    model::GenericModel;
    ignore_optimize_hook = (model.optimize_hook === nothing),
    kwargs...,
)

Оптимизирует модель.

Если оптимизатор еще не задан (см. описание метода set_optimizer), выдается ошибка NoOptimizer.

Если ignore_optimize_hook == true, обработчик оптимизации игнорируется и модель решается так, как если бы он не был задан. Именованные аргументы kwargs передаются в optimize_hook. Если optimize_hook имеет значение nothing и переданы именованные аргументы, выдается ошибка.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> function my_optimize_hook(model; foo)
           println("Hook called with foo = ", foo)
           return optimize!(model; ignore_optimize_hook = true)
       end
my_optimize_hook (generic function with 1 method)

julia> set_optimize_hook(model, my_optimize_hook)
my_optimize_hook (generic function with 1 method)

julia> optimize!(model; foo = 2)
Hook called with foo = 2

# JuMP.optimizer_index — Method

optimizer_index(x::GenericVariableRef)::MOI.VariableIndex
optimizer_index(x::ConstraintRef{<:GenericModel})::MOI.ConstraintIndex

Возвращает индекс переменной или ограничения, соответствующий x в связанной модели unsafe_backend(owner_model(x)).

Эту функцию следует использовать с методом unsafe_backend.

Более безопасной альтернативой является использование backend и index](api.md#JuMP.index-Tuple{ConstraintRef}). Дополнительные сведения см. в docstring методов [backend и unsafe_backend.

Исключения

Если оптимизатор не задан, выдает исключение NoOptimizer.
Если оптимизатор задан, но не присоединен, выдает исключение ErrorException.
Если индекс соединен через мост, выдает исключение ErrorException.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 0)
x

julia> MOI.Utilities.attach_optimizer(model)

julia> highs = unsafe_backend(model)
A HiGHS model with 1 columns and 0 rows.

julia> optimizer_index(x)
MOI.VariableIndex(1)

# JuMP.optimizer_with_attributes — Method

optimizer_with_attributes(optimizer_constructor, attrs::Pair...)

Объединяет конструктор оптимизатора со списком атрибутов attrs. Обратите внимание, что это эквивалентно MOI.OptimizerWithAttributes.

При передаче в конструктор Model или в set_optimizer создает оптимизатор, вызывая optimizer_constructor(), а затем задает атрибуты с помощью set_attribute.

См. также описание методов set_attribute и get_attribute.

Примечание

Строковые имена атрибутов особые для каждого решателя. Нужные атрибуты см. в документации к решателю.

Пример

julia> import HiGHS

julia> optimizer = optimizer_with_attributes(
           HiGHS.Optimizer, "presolve" => "off", MOI.Silent() => true,
       );

julia> model = Model(optimizer);

эквивалентно следующему:

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_attribute(model, "presolve", "off")

julia> set_attribute(model, MOI.Silent(), true)

# JuMP.owner_model — Function

owner_model(s::AbstractJuMPScalar)

Возвращает модель, которой принадлежит скалярное значение s.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> owner_model(x) === model
true

# JuMP.owner_model — Method

owner_model(v::AbstractVariableRef)

Возвращает модель, которой принадлежит v.

Пример

julia> model = Model();

julia> x = @variable(model)
_[1]

julia> owner_model(x) === model
true

# JuMP.owner_model — Method

owner_model(con_ref::ConstraintRef)

Возвращает модель, которой принадлежит con_ref.

# JuMP.parameter_value — Method

parameter_value(x::GenericVariableRef)

Возвращает значение параметра x.

Если x не является параметром, выдает ошибку.

См. также описание ParameterRef, is_parameter и set_parameter_value.

Пример

julia> model = Model();

julia> @variable(model, p in Parameter(2))
p

julia> parameter_value(p)
2.0

julia> set_parameter_value(p, 2.5)

julia> parameter_value(p)
2.5

# JuMP.parse_constraint — Method

parse_constraint(error_fn::Function, expr::Expr)

Точка входа для всех действий, связанных с анализом ограничений.

Аргументы

Функция error_fn передается везде для предоставления более точных сообщений об ошибках.
expr получается из макроса @constraint. Возможны два варианта:
- @constraint(model, expr)
- @constraint(model, name[args], expr) В обоих случаях expr является основным компонентом ограничения.

Поддерживаемый синтаксис

JuMP в настоящее время поддерживает следующие объекты expr:

lhs <= rhs
lhs == rhs
lhs >= rhs
l <= body <= u
u >= body >= l
lhs ⟂ rhs
lhs in rhs
lhs ∈ rhs
z --> {constraint}
!z --> {constraint}
z <--> {constraint}
!z <--> {constraint}
z => {constraint}
!z => {constraint} а также все транслируемые варианты.

Расширения

Инфраструктура, на которой основан метод parse_constraint, является расширяемой. Подробные сведения см. в описании parse_constraint_head и parse_constraint_call.

# JuMP.parse_constraint_call — Method

parse_constraint_call(
    error_fn::Function,
    vectorized::Bool,
    ::Val{op},
    lhs,
    rhs,
) where {op}

Резервный обработчик для бинарных операторов. Это могут быть инфиксные операторы, например @constraint(model, lhs op rhs), или нормальные операторы, например @constraint(model, op(lhs, rhs)).

В обоих случаях форма записи будет преобразована в lhs - rhs in operator_to_set(error_fn, op).

Подробные сведения см. в описании метода operator_to_set.

# JuMP.parse_constraint_call — Method

parse_constraint_call(
    error_fn::Function,
    is_vectorized::Bool,
    ::Val{op},
    args...,
)

Реализуйте этот метод для перехвата операций анализа выражения :call с помощью оператора op.

Расширение макроса ограничений во время анализа является сложной операцией и может влиять на существующий синтаксис JuMP. Прежде чем публиковать код, в котором реализуются эти методы, обсудите возможные последствия в чате разработчиков.

Аргументы

error_fn: функция, которая принимает String и выдает строковую ошибку с описательной информацией о макросе, из которого она была выдана.
is_vectorized: логическое значение, указывающее, следует ли транслировать op.
op: первый элемент поля .args перехватываемого выражения Expr.
args...: поле .args выражения Expr.

Возвращаемые значения

Эта функция должна возвращать следующее.

parse_code::Expr: выражение, содержащее код настройки или перезаписи, который необходимо вызвать перед build_constraint;
build_code::Expr: выражение, которое вызывает build_constraint( или build_constraint.( в зависимости от is_vectorized.

См. также описание методов parse_constraint_head и build_constraint

# JuMP.parse_constraint_head — Method

parse_constraint_head(error_fn::Function, ::Val{head}, args...)

Реализуйте этот метод для перехвата операций анализа выражения с главной частью head.

Аргументы

error_fn: функция, которая принимает String и выдает строковую ошибку с описательной информацией о макросе, из которого она была выдана.
head: поле .head перехватываемого выражения Expr.
args...: поле .args выражения Expr.

Возвращаемые значения

Эта функция должна возвращать следующее.

is_vectorized::Bool: представляет ли выражение транслируемое выражение, например x .<= 1;
parse_code::Expr: выражение, содержащее код настройки или перезаписи, который необходимо вызвать перед build_constraint;
build_code::Expr: выражение, которое вызывает build_constraint( или build_constraint.( в зависимости от is_vectorized.

Существующие реализации

JuMP в настоящее время реализует следующее:

::Val{:call} — перенаправляет вызовы в parse_constraint_call;
::Val{:comparison} — обрабатывает особый случай l <= body <= u.

См. также описание методов parse_constraint_call и build_constraint

# JuMP.parse_one_operator_variable — _Method

parse_one_operator_variable(
    error_fn::Function,
    info_expr::_VariableInfoExpr,
    sense::Val{S},
    value,
) where {S}

Обновляет infoexr для переменного выражения в макросе @variable формы variable name S value.

# JuMP.parse_ternary_variable — _Method

parse_ternary_variable(error_fn, info_expr, lhs_sense, lhs, rhs_sense, rhs)

Обработчик для расширений JuMP, который служит для перехвата операций анализа выражения :comparison, имеющего форму lhs lhs_sense variable rhs_sense rhs.

# JuMP.parse_variable — _Method

parse_variable(error_fn::Function, ::_VariableInfoExpr, args...)

Обработчик для расширений, позволяющий перехватывать операции анализа ограничений неравенства в макросе @variable.

# JuMP.primal_feasibility_report — Method

primal_feasibility_report(
    model::GenericModel{T},
    point::AbstractDict{GenericVariableRef{T},T} = _last_primal_solution(model),
    atol::T = zero(T),
    skip_missing::Bool = false,
)::Dict{Any,T}

Для данного словаря point, в котором переменные сопоставляются с прямыми значениями, возвращает словарь, ключами которого являются ограничения с недопустимостью более заданного допуска atol. Значение, соответствующее каждому ключу, представляет собой соответствующую недопустимость. Недопустимость определяется как расстояние между прямым значением ограничения (см. MOI.ConstraintPrimal) и ближайшей точкой по евклидову расстоянию в соответствующем множестве.

Примечания

Если skip_missing = true, ограничения, содержащие переменные, отсутствующие в point, игнорируются.
Если skip_missing = false и указано частное прямое решение, выдается ошибка.
Если точка не указана, используется прямое решение, полученное при последнем решении модели.

Пример

julia> model = Model();

julia> @variable(model, 0.5 <= x <= 1);

julia> primal_feasibility_report(model, Dict(x => 0.2))
Dict{Any, Float64} with 1 entry:
  x ≥ 0.5 => 0.3

# JuMP.primal_feasibility_report — Method

primal_feasibility_report(
    point::Function,
    model::GenericModel{T};
    atol::T = zero(T),
    skip_missing::Bool = false,
) where {T}

Форма primal_feasibility_report, в которой первым аргументом передается функция, а не словарь вторым аргументом.

Пример

julia> model = Model();

julia> @variable(model, 0.5 <= x <= 1, start = 1.3);

julia> primal_feasibility_report(model) do v
           return start_value(v)
       end
Dict{Any, Float64} with 1 entry:
  x ≤ 1 => 0.3

# JuMP.primal_status — Method

primal_status(model::GenericModel; result::Int = 1)

Возвращает объект MOI.ResultStatusCode, описывающий состояние последнего прямого решения решателя (то есть атрибут MOI.PrimalStatus), связанного с индексом результата result.

См. также описание метода result_count.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> primal_status(model; result = 2)
NO_SOLUTION::ResultStatusCode = 0

# JuMP.print_active_bridges — Method

print_active_bridges(
    [io::IO = stdout,]
    model::GenericModel,
    F::Type,
    S::Type{<:MOI.AbstractSet},
)

Выводит список мостов, необходимых для ограничения типа «F в S».

# JuMP.print_active_bridges — Method

print_active_bridges(
    [io::IO = stdout,]
    model::GenericModel,
    S::Type{<:MOI.AbstractSet},
)

Выводит список мостов, необходимых для добавления переменной, ограниченной множеством S.

# JuMP.print_active_bridges — Method

print_active_bridges([io::IO = stdout,] model::GenericModel)

Выводит список мостов переменных, ограничений и целей, которые в настоящее время используются в модели.

# JuMP.print_active_bridges — Method

print_active_bridges([io::IO = stdout,] model::GenericModel, ::Type{F}) where {F}

Выводит список мостов, необходимых для целевой функции типа F.

# JuMP.print_bridge_graph — Method

 print_bridge_graph([io::IO,] model::GenericModel)

Выводит гиперграф, содержащий все типы переменных, ограничений и целей, которые можно получить путем соединения мостом переменных, ограничений и целей, имеющихся в модели.

Эта функция предназначена для опытных пользователей. Чтобы просмотреть только используемые в настоящее время мосты, используйте вместо этого метод print_active_bridges.

Объяснение выходных данных

Каждый узел гиперграфа соответствует типу переменной, ограничения или цели.

Узлы переменных обозначаются символами [ ].
Узлы ограничений обозначаются символами ( ).
Узлы целей обозначаются символами | |. Число внутри каждой пары скобок — это индекс узла гиперграфа.

Обратите внимание, что этот гиперграф представляет собой полный список возможных преобразований. При создании мостовой модели в этом графе выбираются кратчайшие гиперпути, поэтому многие узлы могут не использоваться.

Дополнительные сведения см. в работе авторов Legat, B., Dowson, O., Garcia, J., and Lubin, M. (2020). MathOptInterface: a data structure for mathematical optimization problems. URL-адрес: https://arxiv.org/abs/2002.03447

# JuMP.quad_terms — Method

quad_terms(quad::GenericQuadExpr{C,V})

Предоставляет итератор по кортежам (coefficient::C, var_1::V, var_2::V) в квадратичной части квадратичного выражения.

# JuMP.raw_status — Method

raw_status(model::GenericModel)

Возвращает причину остановки решателя согласно его собственным данным (то есть атрибут модели MathOptInterface MOI.RawStatusString).

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> raw_status(model)
"optimize not called"

# JuMP.read_from_file — Method

read_from_file(
    filename::String;
    format::MOI.FileFormats.FileFormat = MOI.FileFormats.FORMAT_AUTOMATIC,
    kwargs...,
)

Возвращает модель JuMP, считанную из filename, в формате format.

Если имя файла заканчивается на .gz, он распаковывается с помощью GZip. Если имя файла заканчивается на .bz2, он распаковывается с помощью BZip2.

Другие аргументы kwargs передаются в конструктор Model выбранного формата.

# JuMP.reduced_cost — Method

reduced_cost(x::GenericVariableRef{T})::T where {T}

Возвращает сокращение стоимости, связанное с переменной x.

Одной из интерпретаций сокращения стоимости является изменение целевой функции из-за бесконечно малого ослабления границ переменной.

Этот метод равносилен запросу теневой стоимости активной границы переменной (если она существует и активна).

См. также описание метода shadow_price.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x <= 1);

julia> @objective(model, Max, 2 * x + 1);

julia> optimize!(model)

julia> has_duals(model)
true

julia> reduced_cost(x)
2.0

# JuMP.register — Method

register(
    model::Model,
    s::Symbol,
    dimension::Integer,
    f::Function,
    ∇f::Function,
    ∇²f::Function,
)

Регистрирует пользовательскую функцию f, которая принимает dimension аргументов, в модели model как символ s. В дополнение предоставляются функция градиента ∇f и функция гессиана ∇²f.

∇f и ∇²f должны возвращать числа, соответствующие производным первого и второго порядка функции f.

Совместимость

Примечания

Так как автоматическое дифференцирование не используется, можно предположить, что все входные данные имеют тип Float64.
При dimension > 1 этот метод выдает ошибку.
Символ s не обязательно должен совпадать с f, но это повышает удобочитаемость.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> f(x::Float64) = x^2
f (generic function with 1 method)

julia> ∇f(x::Float64) = 2 * x
∇f (generic function with 1 method)

julia> ∇²f(x::Float64) = 2.0
∇²f (generic function with 1 method)

julia> register(model, :foo, 1, f, ∇f, ∇²f)

julia> @NLobjective(model, Min, foo(x))

# JuMP.register — Method

register(
    model::Model,
    s::Symbol,
    dimension::Integer,
    f::Function,
    ∇f::Function;
    autodiff:Bool = false,
)

Регистрирует пользовательскую функцию f, которая принимает dimension аргументов, в модели model как символ s. В дополнение предоставляется функция градиента ∇f.

Функции f и ∇f должны поддерживать все подтипы Real в качестве аргументов. Не следует предполагать, что входные данные имеют тип Float64.

Совместимость

Примечания

Если функция f является одномерной (то есть dimension == 1), функция ∇f должна возвращать число, представляющее производную первого порядка функции f.
Если функция f является многомерной, функция ∇f должна иметь сигнатуру ∇f(g::AbstractVector{T}, args::T...) where {T<:Real}, где первый аргумент — это вектор g, который изменяется на месте с градиентом.
При autodiff = true и dimension == 1 используйте автоматическое дифференцирование для вычисления производной второго порядка. При autodiff = false будет использоваться только производная первого порядка.
Символ s не обязательно должен совпадать с f, но это повышает удобочитаемость.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> f(x::T) where {T<:Real} = x^2
f (generic function with 1 method)

julia> ∇f(x::T) where {T<:Real} = 2 * x
∇f (generic function with 1 method)

julia> register(model, :foo, 1, f, ∇f; autodiff = true)

julia> @NLobjective(model, Min, foo(x))

julia> model = Model();

julia> @variable(model, x[1:2])
2-element Vector{VariableRef}:
 x[1]
 x[2]

julia> g(x::T, y::T) where {T<:Real} = x * y
g (generic function with 1 method)

julia> function ∇g(g::AbstractVector{T}, x::T, y::T) where {T<:Real}
           g[1] = y
           g[2] = x
           return
       end
∇g (generic function with 1 method)

julia> register(model, :g, 2, g, ∇g)

julia> @NLobjective(model, Min, g(x[1], x[2]))

# JuMP.register — Method

register(
    model::Model,
    op::Symbol,
    dimension::Integer,
    f::Function;
    autodiff:Bool = false,
)

Регистрирует пользовательскую функцию f, которая принимает dimension аргументов, в модели model как символ op.

Функция f должна поддерживать все подтипы Real в качестве аргументов. Не следует предполагать, что входные данные имеют тип Float64.

Совместимость

Примечания

Для этого метода необходимо явным образом задать autodiff = true, так как пользовательская функция градиента ∇f не задана.
Вторая производная вычисляется, только если dimension == 1.
Символ op не обязательно должен совпадать с f, но это повышает удобочитаемость.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> f(x::T) where {T<:Real} = x^2
f (generic function with 1 method)

julia> register(model, :foo, 1, f; autodiff = true)

julia> @NLobjective(model, Min, foo(x))

julia> model = Model();

julia> @variable(model, x[1:2])
2-element Vector{VariableRef}:
 x[1]
 x[2]

julia> g(x::T, y::T) where {T<:Real} = x * y
g (generic function with 1 method)

julia> register(model, :g, 2, g; autodiff = true)

julia> @NLobjective(model, Min, g(x[1], x[2]))

# JuMP.relative_gap — Method

relative_gap(model::GenericModel)

Возвращает окончательный относительный разрыв оптимальности после вызова optimize!(model).

Точное значение зависит от реализации MOI.RelativeGap конкретным решателем, используемым для оптимизации.

Эта функция эквивалентна запросу атрибута MOI.RelativeGap.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 1, Int);

julia> @objective(model, Min, 2 * x + 1);

julia> optimize!(model)

julia> relative_gap(model)
0.0

# JuMP.relax_integrality — Method

relax_integrality(model::GenericModel)

Изменяет модель (model), «ослабляя» все ограничения двоичности и целочисленности переменных. В частности:

Ограничения двоичности удаляются, а границы переменных при необходимости ужесточаются, чтобы переменная была ограничена интервалом ].
Ограничения целочисленности удаляются без изменения границ переменных.
При наличии полунепрерывных или полуцелочисленных ограничений возникает ошибка (поддержка таких ограничений может быть добавлена в будущем).
Все остальные ограничения игнорируются (остаются без изменений). Сюда относятся дискретные ограничения, такие как SOS и индикаторные ограничения.

Пример

julia> model = Model();

julia> @variable(model, x, Bin);

julia> @variable(model, 1 <= y <= 10, Int);

julia> @objective(model, Min, x + y);

julia> undo_relax = relax_integrality(model);

julia> print(model)
Min x + y
Subject to
 x ≥ 0
 y ≥ 1
 x ≤ 1
 y ≤ 10

julia> undo_relax()

julia> print(model)
Min x + y
Subject to
 y ≥ 1
 y ≤ 10
 y integer
 x binary

# JuMP.relax_with_penalty! — Method

relax_with_penalty!(
    model::GenericModel{T},
    [penalties::Dict{ConstraintRef,T}];
    [default::Union{Nothing,Real} = nothing,]
) where {T}

Изменяет модель на месте с уничтожением с целью ослабления ограничений со штрафами.

Это разрушающая подпрограмма, которая изменяет модель на месте. Чтобы не изменять исходную модель, используйте метод copy_model для создания копии перед вызовом relax_with_penalty!.

Переформулировка

Подробные сведения о переформулировке см. в описании MOI.Utilities.ScalarPenaltyRelaxation.

Для каждого ограничения ci штраф, передаваемый в MOI.Utilities.ScalarPenaltyRelaxation, равен get(penalties, ci, default). Если значение равно nothing, поскольку ci не существует в penalties и default = nothing, ограничение пропускается.

Возвращаемое значение

Эта функция возвращает словарь Dict{ConstraintRef,AffExpr}, в котором индекс каждого ограничения сопоставляется с соответствующим выражением y + z как AffExpr. При оптимальном решении значение этих функций запрашивается с целью вычислить нарушение каждого ограничения.

Ослабление подмножества ограничений

Чтобы ослабить подмножество ограничений, передайте словарь penalties и множество default = nothing.

Пример

julia> function new_model()
           model = Model()
           @variable(model, x)
           @objective(model, Max, 2x + 1)
           @constraint(model, c1, 2x - 1 <= -2)
           @constraint(model, c2, 3x >= 0)
           return model
       end
new_model (generic function with 1 method)

julia> model_1 = new_model();

julia> penalty_map = relax_with_penalty!(model_1; default = 2.0);

julia> penalty_map[model_1[:c1]]
_[3]

julia> penalty_map[model_1[:c2]]
_[2]

julia> print(model_1)
Max 2 x - 2 _[2] - 2 _[3] + 1
Subject to
 c2 : 3 x + _[2] ≥ 0
 c1 : 2 x - _[3] ≤ -1
 _[2] ≥ 0
 _[3] ≥ 0

julia> model_2 = new_model();

julia> relax_with_penalty!(model_2, Dict(model_2[:c2] => 3.0))
Dict{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, ScalarShape}, AffExpr} with 1 entry:
  c2 : 3 x + _[2] ≥ 0 => _[2]

julia> print(model_2)
Max 2 x - 3 _[2] + 1
Subject to
 c2 : 3 x + _[2] ≥ 0
 c1 : 2 x ≤ -1
 _[2] ≥ 0

# JuMP.remove_bridge — Method

remove_bridge(
    model::GenericModel{S},
    BT::Type{<:MOI.Bridges.AbstractBridge};
    coefficient_type::Type{T} = S,
) where {S,T}

Удаляет BT{T} из списка мостов, которые можно использовать для преобразования неподдерживаемых ограничений в эквивалентную форму, поддерживаемую оптимизатором.

См. также описание метода add_bridge.

Пример

julia> model = Model();

julia> add_bridge(model, MOI.Bridges.Constraint.SOCtoNonConvexQuadBridge)

julia> remove_bridge(model, MOI.Bridges.Constraint.SOCtoNonConvexQuadBridge)

julia> add_bridge(
           model,
           MOI.Bridges.Constraint.NumberConversionBridge;
           coefficient_type = Complex{Float64},
       )

julia> remove_bridge(
           model,
           MOI.Bridges.Constraint.NumberConversionBridge;
           coefficient_type = Complex{Float64},
       )

# JuMP.reshape_set — Function

reshape_set(vectorized_set::MOI.AbstractSet, shape::AbstractShape)

Возвращает множество в его исходной форме shape на основе векторизованной формы vectorized_form.

Пример

Для SymmetricMatrixShape векторизованной формы [1, 2, 3] in MOI.PositiveSemidefinieConeTriangle(2) следующий код возвращает множество исходного ограничения Symmetric(Matrix[1 2; 2 3]) in PSDCone():

julia> reshape_set(MOI.PositiveSemidefiniteConeTriangle(2), SymmetricMatrixShape(2))
PSDCone()

# JuMP.reshape_vector — Function

reshape_vector(vectorized_form::Vector, shape::AbstractShape)

Возвращает объект в его исходной форме shape на основе векторизованной формы vectorized_form.

Пример

Для SymmetricMatrixShape векторизованной формы [1, 2, 3] следующий код возвращает матрицу Symmetric(Matrix[1 2; 2 3]):

julia> reshape_vector([1, 2, 3], SymmetricMatrixShape(2))
2×2 LinearAlgebra.Symmetric{Int64, Matrix{Int64}}:
 1  2
 2  3

# JuMP.result_count — Method

result_count(model::GenericModel)

Возвращает количество результатов, доступных для запроса после вызова optimize!.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> result_count(model)
0

# JuMP.reverse_sense — Function

reverse_sense(::Val{T}) where {T}

Для указанного символа (не)равенства T возвращает новый объект Val с противоположным символом (не)равенства.

Эта функция предназначена для использования в расширениях JuMP.

Пример

julia> reverse_sense(Val(:>=))
Val{:<=}()

# JuMP.set_attribute — Method

set_attribute(model::GenericModel, attr::MOI.AbstractModelAttribute, value)
set_attribute(x::GenericVariableRef, attr::MOI.AbstractVariableAttribute, value)
set_attribute(cr::ConstraintRef, attr::MOI.AbstractConstraintAttribute, value)

Устанавливает значение относящегося к решателю атрибута attr равным value.

Эквивалентно вызову MOI.set с соответствующей моделью MOI, а для переменных и ограничений — с соответствующим индексом MOI.VariableIndex или MOI.ConstraintIndex.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, c, 2 * x <= 1)
c : 2 x ≤ 1

julia> set_attribute(model, MOI.Name(), "model_new")

julia> set_attribute(x, MOI.VariableName(), "x_new")

julia> set_attribute(c, MOI.ConstraintName(), "c_new")

# JuMP.set_attribute — Method

set_attribute(
    model::Union{GenericModel,MOI.OptimizerWithAttributes},
    attr::Union{AbstractString,MOI.AbstractOptimizerAttribute},
    value,
)

Устанавливает значение относящегося к решателю атрибута attr равным value.

Эквивалентно вызову MOI.set с соответствующей моделью MOI.

Если attr — это строка AbstractString, она преобразуется в MOI.RawOptimizerAttribute.

Пример

julia> import HiGHS

julia> opt = optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false);

julia> model = Model(opt);

julia> set_attribute(model, "output_flag", false)

julia> set_attribute(model, MOI.RawOptimizerAttribute("output_flag"), true)

julia> set_attribute(opt, "output_flag", true)

julia> set_attribute(opt, MOI.RawOptimizerAttribute("output_flag"), false)

# JuMP.set_attributes — Method

set_attributes(
    destination::Union{
        GenericModel,
        MOI.OptimizerWithAttributes,
        GenericVariableRef,
        ConstraintRef,
    },
    pairs::Pair...,
)

Вызывает set_attribute(destination, attribute, value) для каждой пары из списка attribute => value.

См. также описание методов set_attribute и get_attribute.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> set_attributes(model, "tol" => 1e-4, "max_iter" => 100)

эквивалентно следующему:

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> set_attribute(model, "tol", 1e-4)

julia> set_attribute(model, "max_iter", 100)

# JuMP.set_binary — Method

set_binary(v::GenericVariableRef)

Добавляет ограничение, согласно которому переменная v должна принимать значения из множества .

См. также описание BinaryRef, is_binary и unset_binary.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> is_binary(x)
false

julia> set_binary(x)

julia> is_binary(x)
true

# JuMP.set_dual_start_value — Method

set_dual_start_value(con_ref::ConstraintRef, value)

Устанавливает двойственное начальное значение (атрибут MOI ConstraintDualStart) ограничения value равным con_ref.

Чтобы удалить двойственное начальное значение, установите его равным nothing.

См. также описание метода dual_start_value.

Пример

julia> model = Model();

julia> @variable(model, x, start = 2.0);

julia> @constraint(model, c, [2x] in Nonnegatives())
c : [2 x] ∈ MathOptInterface.Nonnegatives(1)

julia> set_dual_start_value(c, [0.0])

julia> dual_start_value(c)
1-element Vector{Float64}:
 0.0

julia> set_dual_start_value(c, nothing)

julia> dual_start_value(c)

# JuMP.set_integer — Method

set_integer(variable_ref::GenericVariableRef)

Добавляет ограничение целочисленности для переменной variable_ref.

См. также описание IntegerRef, is_integer и unset_integer.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> is_integer(x)
false

julia> set_integer(x)

julia> is_integer(x)
true

# JuMP.set_lower_bound — Method

set_lower_bound(v::GenericVariableRef, lower::Number)

Задает нижнюю границу переменной. Если ее не существует, создает новое ограничение нижней границы.

См. также описание LowerBoundRef, has_lower_bound, lower_bound и delete_lower_bound.

Пример

julia> model = Model();

julia> @variable(model, x >= 1.0);

julia> lower_bound(x)
1.0

julia> set_lower_bound(x, 2.0)

julia> lower_bound(x)
2.0

# JuMP.set_name — Method

set_name(con_ref::ConstraintRef, s::AbstractString)

Задает атрибут имени ограничения.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, c, [2x] in Nonnegatives())
c : [2 x] ∈ MathOptInterface.Nonnegatives(1)

julia> set_name(c, "my_constraint")

julia> name(c)
"my_constraint"

julia> c
my_constraint : [2 x] ∈ MathOptInterface.Nonnegatives(1)

# JuMP.set_name — Method

set_name(v::GenericVariableRef, s::AbstractString)

Задает атрибут имени переменной.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> set_name(x, "x_foo")

julia> x
x_foo

julia> name(x)
"x_foo"

# JuMP.set_nonlinear_dual_start_value — Method

set_nonlinear_dual_start_value(
    model::Model,
    start::Union{Nothing,Vector{Float64}},
)

Задает значение атрибута MOI MOI.NLPBlockDualStart.

Совместимость

Начальный вектор соответствует лагранжевым двойственным функциям нелинейных ограничений в порядке, заданном методом all_nonlinear_constraints. То есть необходимо передать один начальный вектор, соответствующий всем нелинейным ограничениям, в одном вызове функции; задавать двойственное начальное значение для нелинейных ограничений по одному нельзя. В примере ниже показано, как с помощью all_nonlinear_constraints создать сопоставление между ссылками на нелинейные ограничения и начальным вектором.

Чтобы отменить предыдущее начальное значение, передайте nothing.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> nl1 = @NLconstraint(model, x[1] <= sqrt(x[2]));

julia> nl2 = @NLconstraint(model, x[1] >= exp(x[2]));

julia> start = Dict(nl1 => -1.0, nl2 => 1.0);

julia> start_vector = [start[con] for con in all_nonlinear_constraints(model)]
2-element Vector{Float64}:
 -1.0
  1.0

julia> set_nonlinear_dual_start_value(model, start_vector)

julia> nonlinear_dual_start_value(model)
2-element Vector{Float64}:
 -1.0
  1.0

# JuMP.set_nonlinear_objective — Method

set_nonlinear_objective(
    model::Model,
    sense::MOI.OptimizationSense,
    expr::Expr,
)

Задает выражение expr в качестве нелинейной целевой функции model с назначением оптимизации sense.

Эта функция наиболее полезна в случае, если выражение expr генерируется программным образом и использовать @NLobjective невозможно.

Совместимость

Примечания

Переменные следует интерполировать напрямую в выражение expr.
Вместо Min и Max следует использовать MIN_SENSE или MAX_SENSE.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> set_nonlinear_objective(model, MIN_SENSE, :($(x) + $(x)^2))

# JuMP.set_normalized_coefficient — Method

set_normalized_coefficient(
    constraints::AbstractVector{<:ConstraintRef},
    variables_1:AbstractVector{<:GenericVariableRef},
    variables_2:AbstractVector{<:GenericVariableRef},
    values::AbstractVector{<:Number},
)

Устанавливает несколько квадратичных коэффициентов, связанных с variables_1 и variables_2 в ограничениях constraints, равными values.

Обратите внимание, что перед этим шагом JuMP объединяет члены, содержащие одну и ту же переменную. Например, для ограничения 2x^2 + 3x^2 <= 2 вызов set_normalized_coefficient(con, [x], [x], [4]) создаст ограничение 4x^2 <= 2.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> @constraint(model, con, 2x[1]^2 + 3 * x[1] * x[2] + x[2] <= 2)
con : 2 x[1]² + 3 x[1]*x[2] + x[2] ≤ 2

julia> set_normalized_coefficient([con, con], [x[1], x[1]], [x[1], x[2]], [4, 5])

julia> con
con : 4 x[1]² + 5 x[1]*x[2] + x[2] ≤ 2

# JuMP.set_normalized_coefficient — Method

set_normalized_coefficient(
    constraints::AbstractVector{<:ConstraintRef},
    variables::AbstractVector{<:GenericVariableRef},
    values::AbstractVector{<:Number},
)

Устанавливает коэффициенты переменных variables в ограничениях constraints равными values.

Обратите внимание, что перед этим шагом JuMP объединяет члены, содержащие одну и ту же переменную. Например, для ограничения 2x + 3x <= 2 вызов set_normalized_coefficient(con, [x], [4]) создаст ограничение 4x <= 2.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @variable(model, y)
y

julia> @constraint(model, con, 2x + 3x + 4y <= 2)
con : 5 x + 4 y ≤ 2

julia> set_normalized_coefficient([con, con], [x, y], [6, 7])

julia> con
con : 6 x + 7 y ≤ 2

# JuMP.set_normalized_coefficient — Method

set_normalized_coefficient(
    constraint::ConstraintRef,
    variable_1:GenericVariableRef,
    variable_2:GenericVariableRef,
    value::Number,
)

Устанавливает квадратичный коэффициент, связанный с variable_1 и variable_2 в ограничении constraint, равным value.

Обратите внимание, что перед этим шагом JuMP объединяет члены, содержащие одну и ту же переменную. Например, для ограничения 2x^2 + 3x^2 <= 2 вызов set_normalized_coefficient(con, x, x, 4) создаст ограничение 4x^2 <= 2.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> @constraint(model, con, 2x[1]^2 + 3 * x[1] * x[2] + x[2] <= 2)
con : 2 x[1]² + 3 x[1]*x[2] + x[2] ≤ 2

julia> set_normalized_coefficient(con, x[1], x[1], 4)

julia> set_normalized_coefficient(con, x[1], x[2], 5)

julia> con
con : 4 x[1]² + 5 x[1]*x[2] + x[2] ≤ 2

# JuMP.set_normalized_coefficient — Method

set_normalized_coefficient(
    con_ref::ConstraintRef,
    variable::AbstractVariableRef,
    new_coefficients::Vector{Tuple{Int64,T}},
)

Устанавливает коэффициенты переменной variable в ограничении con_ref равными new_coefficients, где каждый элемент в new_coefficients представляет собой кортеж, в котором строка сопоставляется с новым коэффициентом.

Обратите внимание, что во время создания ограничения перед этим шагом JuMP объединяет члены, содержащие одну и ту же переменную.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, con, [2x + 3x, 4x] in MOI.Nonnegatives(2))
con : [5 x, 4 x] ∈ MathOptInterface.Nonnegatives(2)

julia> set_normalized_coefficient(con, x, [(1, 2.0), (2, 5.0)])

julia> con
con : [2 x, 5 x] ∈ MathOptInterface.Nonnegatives(2)

# JuMP.set_normalized_coefficient — Method

set_normalized_coefficient(
    constraint::ConstraintRef,
    variable::GenericVariableRef,
    value::Number,
)

Устанавливает коэффициент переменной variable в ограничении constraint равным value.

Обратите внимание, что перед этим шагом JuMP объединяет члены, содержащие одну и ту же переменную. Например, для ограничения 2x + 3x <= 2 вызов set_normalized_coefficient(con, x, 4) создаст ограничение 4x <= 2.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @constraint(model, con, 2x + 3x <= 2)
con : 5 x ≤ 2

julia> set_normalized_coefficient(con, x, 4)

julia> con
con : 4 x ≤ 2

# JuMP.set_normalized_coefficients — Method

set_normalized_coefficients(
    constraint::ConstraintRef{<:AbstractModel,<:MOI.ConstraintIndex{F}},
    variable::AbstractVariableRef,
    new_coefficients::Vector{Tuple{Int64,T}},
) where {T,F<:Union{MOI.VectorAffineFunction{T},MOI.VectorQuadraticFunction{T}}}

Нерекомендованный метод, вызов которого теперь перенаправляется в set_normalized_coefficient.

# JuMP.set_normalized_rhs — Method

set_normalized_rhs(
    constraints::AbstractVector{<:ConstraintRef},
    values::AbstractVector{<:Number}
)

Устанавливает члены в правой части ограничений constraints равными values.

Обратите внимание, что перед этим шагом JuMP выводит все свободные члены в правую часть ограничения. Например, для ограничения 2x + 1 <= 2 вызов set_normalized_rhs([con], [4]) создаст ограничение 2x <= 4, а не 2x + 1 <= 4.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, con1, 2x + 1 <= 2)
con1 : 2 x ≤ 1

julia> @constraint(model, con2, 3x + 2 <= 4)
con2 : 3 x ≤ 2

julia> set_normalized_rhs([con1, con2], [4, 5])

julia> con1
con1 : 2 x ≤ 4

julia> con2
con2 : 3 x ≤ 5

# JuMP.set_normalized_rhs — Method

set_normalized_rhs(constraint::ConstraintRef, value::Number)

Устанавливает правый член ограничения constraint равным value.

Обратите внимание, что перед этим шагом JuMP выводит все свободные члены в правую часть ограничения. Например, для ограничения 2x + 1 <= 2 вызов set_normalized_rhs(con, 4) создаст ограничение 2x <= 4, а не 2x + 1 <= 4.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @constraint(model, con, 2x + 1 <= 2)
con : 2 x ≤ 1

julia> set_normalized_rhs(con, 4)

julia> con
con : 2 x ≤ 4

# JuMP.set_objective — Method

set_objective(model::AbstractModel, sense::MOI.OptimizationSense, func)

Функциональный эквивалент макроса @objective.

Одновременно задает целевое назначение и целевую функцию, что равносильно вызову set_objective_sense и set_objective_function по отдельности.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> set_objective(model, MIN_SENSE, x)

# JuMP.set_objective_coefficient — Method

set_objective_coefficient(
    model::GenericModel{T},
    variables_1::AbstractVector{<:GenericVariableRef{T}},
    variables_2::AbstractVector{<:GenericVariableRef{T}},
    coefficients::AbstractVector{<:Real},
) where {T}

Устанавливает несколько коэффициентов квадратичной целевой функции, связанных с variables_1 и variables_2, равными coefficients за один вызов.

Обратите внимание: если задана нелинейная целевая функция, эта функция выдаст ошибку.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> @objective(model, Min, x[1]^2 + x[1] * x[2])
x[1]² + x[1]*x[2]

julia> set_objective_coefficient(model, [x[1], x[1]], [x[1], x[2]], [2, 3])

julia> objective_function(model)
2 x[1]² + 3 x[1]*x[2]

# JuMP.set_objective_coefficient — Method

set_objective_coefficient(
    model::GenericModel,
    variables::Vector{<:GenericVariableRef},
    coefficients::Vector{<:Real},
)

Устанавливает несколько коэффициентов линейной целевой функции, связанных с variables, равными coefficients за один вызов.

Обратите внимание: если задана нелинейная целевая функция, эта функция выдаст ошибку.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @variable(model, y);

julia> @objective(model, Min, 3x + 2y + 1)
3 x + 2 y + 1

julia> set_objective_coefficient(model, [x, y], [5, 4])

julia> objective_function(model)
5 x + 4 y + 1

# JuMP.set_objective_coefficient — Method

set_objective_coefficient(
    model::GenericModel{T},
    variable_1::GenericVariableRef{T},
    variable_2::GenericVariableRef{T},
    coefficient::Real,
) where {T}

Устанавливает коэффициент квадратичной целевой функции, связанный с variable_1 и variable_2, равным coefficient.

Обратите внимание: если задана нелинейная целевая функция, эта функция выдаст ошибку.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> @objective(model, Min, x[1]^2 + x[1] * x[2])
x[1]² + x[1]*x[2]

julia> set_objective_coefficient(model, x[1], x[1], 2)

julia> set_objective_coefficient(model, x[1], x[2], 3)

julia> objective_function(model)
2 x[1]² + 3 x[1]*x[2]

# JuMP.set_objective_coefficient — Method

set_objective_coefficient(
    model::GenericModel,
    variable::GenericVariableRef,
    coefficient::Real,
)

Устанавливает коэффициент линейной целевой функции, связанный с variable, равным coefficient.

Обратите внимание: если задана нелинейная целевая функция, эта функция выдаст ошибку.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @objective(model, Min, 2x + 1)
2 x + 1

julia> set_objective_coefficient(model, x, 3)

julia> objective_function(model)
3 x + 1

# JuMP.set_objective_function — Function

set_objective_function(model::GenericModel, func::MOI.AbstractFunction)
set_objective_function(model::GenericModel, func::AbstractJuMPScalar)
set_objective_function(model::GenericModel, func::Real)
set_objective_function(model::GenericModel, func::Vector{<:AbstractJuMPScalar})

Задает указанную функцию в качестве целевой функции модели.

Если нужно задать целевое назначение, см. описание метода set_objective_sense.

Это низкоуровневые функции; задавать целевую функцию рекомендуется с помощью макроса @objective.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @objective(model, Min, x);

julia> objective_function(model)
x

julia> set_objective_function(model, 2 * x + 1)

julia> objective_function(model)
2 x + 1

# JuMP.set_objective_sense — Method

set_objective_sense(model::GenericModel, sense::MOI.OptimizationSense)

Задает указанное назначение в качестве целевого назначения модели.

Если нужно задать целевую функцию, см. описание функции set_objective_function.

Это низкоуровневые функции; задавать целевую функцию рекомендуется с помощью макроса @objective.

Пример

julia> model = Model();

julia> objective_sense(model)
FEASIBILITY_SENSE::OptimizationSense = 2

julia> set_objective_sense(model, MOI.MAX_SENSE)

julia> objective_sense(model)
MAX_SENSE::OptimizationSense = 1

# JuMP.set_optimize_hook — Method

set_optimize_hook(model::GenericModel, f::Union{Function,Nothing})

Задает функцию f в качестве обработчика оптимизации для model.

Функция f должна иметь сигнатуру f(model::GenericModel; kwargs...), где kwargs — это аргументы, которые передаются в optimize!.

Примечания

Обработчик оптимизации, как правило, должен каким-либо образом изменять модель или некоторое внешнее состояние, а затем вызывать optimize!(model; ignore_optimize_hook = true) для оптимизации задачи в обход обработчика.
Чтобы отменить заданный обработчик оптимизации, используйте вызов set_optimize_hook(model, nothing).

Пример

julia> model = Model();

julia> function my_hook(model::Model; kwargs...)
           println(kwargs)
           println("Calling with `ignore_optimize_hook = true`")
           optimize!(model; ignore_optimize_hook = true)
           return
       end
my_hook (generic function with 1 method)

julia> set_optimize_hook(model, my_hook)
my_hook (generic function with 1 method)

julia> optimize!(model; test_arg = true)
Base.Pairs{Symbol, Bool, Tuple{Symbol}, @NamedTuple{test_arg::Bool}}(:test_arg => 1)
Calling with `ignore_optimize_hook = true`
ERROR: NoOptimizer()
[...]

# JuMP.set_optimizer — Method

set_optimizer(
    model::GenericModel,
    optimizer_factory;
    add_bridges::Bool = true,
)

Создает пустой экземпляр MathOptInterface.AbstractOptimizer, вызывая optimizer_factory(), и устанавливает его в качестве оптимизатора модели model. В частности, объект optimizer_factory должен поддерживать вызов без аргументов и возвращать пустой экземпляр MathOptInterface.AbstractOptimizer.

Если аргумент add_bridges имеет значение true, ограничения и целевые функции, которые не поддерживаются оптимизатором, автоматически связываются мостом с эквивалентной поддерживаемой формулировкой. Передача значения add_bridges = false может повысить производительность, если решатель изначально поддерживает все элементы в model.

Сведения о настройке характерных для решателя параметров оптимизатора см. в описании метода set_attribute.

Пример

julia> import HiGHS

julia> model = Model();

julia> set_optimizer(model, () -> HiGHS.Optimizer())

julia> set_optimizer(model, HiGHS.Optimizer; add_bridges = false)

# JuMP.set_optimizer_attribute — Method

set_optimizer_attribute(
    model::Union{GenericModel,MOI.OptimizerWithAttributes},
    attr::Union{AbstractString,MOI.AbstractOptimizerAttribute},
    value,
)

Устанавливает относящийся к решателю атрибут решателя attr в model равным value.

Если attr — это строка AbstractString, данный метод эквивалентен вызову set_optimizer_attribute(model, MOI.RawOptimizerAttribute(name), value).

Совместимость

Этот метод сохранится во всех выпусках JuMP v1.X, но может быть удален в будущем выпуске v2.0. Вместо него рекомендуется использовать set_attribute.

См. также описание методов set_optimizer_attributes и get_optimizer_attribute.

Пример

julia> model = Model();

julia> set_optimizer_attribute(model, MOI.Silent(), true)

# JuMP.set_optimizer_attributes — Method

set_optimizer_attributes(
    model::Union{GenericModel,MOI.OptimizerWithAttributes},
    pairs::Pair...,
)

Вызывает set_optimizer_attribute(model, attribute, value) для каждой пары из списка attribute => value.

Совместимость

Этот метод сохранится во всех выпусках JuMP v1.X, но может быть удален в будущем выпуске v2.0. Вместо него рекомендуется использовать set_attributes.

См. также описание методов set_optimizer_attribute и get_optimizer_attribute.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> set_optimizer_attributes(model, "tol" => 1e-4, "max_iter" => 100)

эквивалентно следующему:

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> set_optimizer_attribute(model, "tol", 1e-4)

julia> set_optimizer_attribute(model, "max_iter", 100)

# JuMP.set_parameter_value — Method

set_parameter_value(x::GenericVariableRef, value)

Изменяет ограничение параметра для переменной x на value.

Если x не является параметром, выдает ошибку.

См. также описание ParameterRef, is_parameter и parameter_value.

Пример

julia> model = Model();

julia> @variable(model, p in Parameter(2))
p

julia> parameter_value(p)
2.0

julia> set_parameter_value(p, 2.5)

julia> parameter_value(p)
2.5

# JuMP.set_silent — Method

set_silent(model::GenericModel)

Имеет приоритет над всеми остальными атрибутами, управляющими уровнем детализации, и предписывает решателю не выводить никаких данных.

См. также описание метода unset_silent.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> set_silent(model)

julia> get_attribute(model, MOI.Silent())
true

julia> unset_silent(model)

julia> get_attribute(model, MOI.Silent())
false

# JuMP.set_start_value — Method

set_start_value(con_ref::ConstraintRef, value)

Устанавливает прямое начальное значение (MOI.ConstraintPrimalStart) ограничения con_ref равным value.

Чтобы удалить прямое начальное значение, установите его равным nothing.

См. также описание метода start_value.

Пример

julia> model = Model();

julia> @variable(model, x, start = 2.0);

julia> @constraint(model, c, [2x] in Nonnegatives())
c : [2 x] ∈ MathOptInterface.Nonnegatives(1)

julia> set_start_value(c, [4.0])

julia> start_value(c)
1-element Vector{Float64}:
 4.0

julia> set_start_value(c, nothing)

julia> start_value(c)

# JuMP.set_start_value — Method

set_start_value(variable::GenericVariableRef, value::Union{Real,Nothing})

Устанавливает начальное значение (MOI.VariablePrimalStart) переменной variable равным value.

Чтобы отменить начальное значение, передайте nothing.

Обратите внимание: значение VariablePrimalStart иногда называют «началом MIP» или «мягким началом».

См. также описание методов has_start_value и start_value.

Пример

julia> model = Model();

julia> @variable(model, x, start = 1.5);

julia> @variable(model, y);

julia> has_start_value(x)
true

julia> has_start_value(y)
false

julia> start_value(x)
1.5

julia> set_start_value(x, nothing)

julia> has_start_value(x)
false

julia> set_start_value(y, 2.0)

julia> has_start_value(y)
true

julia> start_value(y)
2.0

# JuMP.set_start_values — Method

set_start_values(
    model::GenericModel;
    variable_primal_start::Union{Nothing,Function} = value,
    constraint_primal_start::Union{Nothing,Function} = value,
    constraint_dual_start::Union{Nothing,Function} = dual,
    nonlinear_dual_start::Union{Nothing,Function} = nonlinear_dual_start_value,
)

Задает прямое и двойственное начальные значения в model с помощью предоставленных функций.

Если какой-либо именованный аргумент равен nothing, соответствующее начальное значение пропускается.

Если оптимизатор не поддерживает задание начального значения, значение пропускается.

variable_primal_start

Эта функция управляет прямым начальным решением для переменных. Она эквивалентна вызову set_start_value](api.md#JuMP.set_start_value-Tuple{ConstraintRef{<:AbstractModel, <:MathOptInterface.ConstraintIndex{<:MathOptInterface.AbstractVectorFunction, <:MathOptInterface.AbstractVectorSet}}, Any}) для каждой переменной или заданию атрибута [MOI.VariablePrimalStart.

Если это функция, она должна иметь форму variable_primal_start(x::VariableRef), сопоставляющую каждую переменную x с прямым начальным значением.

По умолчанию используется value.

constraint_primal_start

Эта функция управляет прямым начальным решением для ограничений. Она эквивалентна вызову set_start_value](api.md#JuMP.set_start_value-Tuple{ConstraintRef{<:AbstractModel, <:MathOptInterface.ConstraintIndex{<:MathOptInterface.AbstractVectorFunction, <:MathOptInterface.AbstractVectorSet}}, Any}) для каждого ограничения или заданию атрибута [MOI.ConstraintPrimalStart.

Если это функция, она должна иметь форму constraint_primal_start(ci::ConstraintRef), сопоставляющую каждое ограничение ci с прямым начальным значением.

По умолчанию используется value.

constraint_dual_start

Эта функция управляет двойственным начальным решением для ограничений. Она эквивалентна вызову set_dual_start_value](api.md#JuMP.set_dual_start_value-Tuple{ConstraintRef{<:AbstractModel, <:MathOptInterface.ConstraintIndex{<:MathOptInterface.AbstractVectorFunction, <:MathOptInterface.AbstractVectorSet}}, Any}) для каждого ограничения или заданию атрибута [MOI.ConstraintDualStart.

Если это функция, она должна иметь форму constraint_dual_start(ci::ConstraintRef), сопоставляющую каждое ограничение ci с двойственным начальным значением.

По умолчанию используется dual.

nonlinear_dual_start

Эта функция управляет двойственным начальным решением для нелинейных ограничений. Она эквивалентна вызову set_nonlinear_dual_start_value.

Если это функция, она должна иметь форму nonlinear_dual_start(model::GenericModel), возвращающую вектор, который соответствует двойственному начальному значению ограничений.

По умолчанию используется nonlinear_dual_start_value.

# JuMP.set_string_names_on_creation — Method

set_string_names_on_creation(model::GenericModel, value::Bool)

Устанавливает именованный аргумент set_string_name по умолчанию в макросах @variable и @constraint равным value.

Именованный аргумент set_string_name определяет, следует ли присвоить имена типа String всем переменным и ограничениям в model.

По умолчанию value имеет значение true. Однако для больших моделей вызов set_string_names_on_creation(model, false) может повысить производительность за счет ухудшения удобочитаемости выводимых данных и сообщений журнала решателя.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_string_names_on_creation(model)
true

julia> set_string_names_on_creation(model, false)

julia> set_string_names_on_creation(model)
false

# JuMP.set_time_limit_sec — Method

set_time_limit_sec(model::GenericModel, limit::Float64)

Задает ограничение по времени (в секундах) для решателя.

Ограничение можно снять, используя метод unset_time_limit_sec или присвоив limit значение nothing.

См. также описание методов unset_time_limit_sec и time_limit_sec.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> time_limit_sec(model)

julia> set_time_limit_sec(model, 60.0)

julia> time_limit_sec(model)
60.0

julia> unset_time_limit_sec(model)

julia> time_limit_sec(model)

# JuMP.set_upper_bound — Method

set_upper_bound(v::GenericVariableRef, upper::Number)

Задает верхнюю границу переменной. Если ее не существует, создает новое ограничение верхней границы.

См. также описание UpperBoundRef, has_upper_bound, upper_bound и delete_upper_bound.

Пример

julia> model = Model();

julia> @variable(model, x <= 1.0);

julia> upper_bound(x)
1.0

julia> set_upper_bound(x, 2.0)

julia> upper_bound(x)
2.0

# JuMP.set_value — Method

set_value(p::NonlinearParameter, v::Number)

Сохраняет значение v в нелинейном параметре p.

Совместимость

Пример

julia> model = Model();

julia> @NLparameter(model, p == 0)
p == 0.0

julia> set_value(p, 5)
5

julia> value(p)
5.0

# JuMP.shadow_price — Method

shadow_price(con_ref::ConstraintRef)

Возвращает величину изменения целевой функции из-за бесконечно малого ослабления ограничения.

Теневая стоимость вычисляется на основе dual, и ее можно запросить только тогда, когда has_duals имеет значение true, а целевое назначение — MIN_SENSE или MAX_SENSE (но не FEASIBILITY_SENSE).

См. также описание метода reduced_cost.

Сравнение с dual

Теневые стоимости либо не отличаются от значения dual, либо отличаются только знаком в зависимости от целевого назначения. Различия представлены в таблице:

Min Max

	`Min`	`Max`
`f(x) <= b`	`+1`	`-1`
`f(x) >= b`	`-1`	`+1`

f(x) <= b

+1

-1

f(x) >= b

-1

+1

Примечания

Эта функция просто преобразует знак значения dual и не проверяет условия, необходимые для интерпретации чувствительности теневой стоимости. Например, вызывающая сторона отвечает за проверку сходимости решателя к оптимальной прямо-двойственной паре или к доказательству недопустимости.
Это вычисление зависит от текущего целевого назначения модели. Если оно изменилось с момента последнего решения, результаты будут неверными.
Ослабление ограничений равенства (и, следовательно, теневой стоимости) определяется в зависимости от активного назначения ограничения равенства.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x);

julia> @constraint(model, c, x <= 1)
c : x ≤ 1

julia> @objective(model, Max, 2 * x + 1);

julia> optimize!(model)

julia> has_duals(model)
true

julia> shadow_price(c)
2.0

# JuMP.shape — Function

shape(c::AbstractConstraint)::AbstractShape

Возвращает форму ограничения c.

Пример

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> c = @constraint(model, x[2] <= 1);

julia> shape(constraint_object(c))
ScalarShape()

julia> d = @constraint(model, x in SOS1());

julia> shape(constraint_object(d))
VectorShape()

# JuMP.show_backend_summary — Method

show_backend_summary(io::IO, model::GenericModel)

Выводит сводку по оптимизатору, на котором основана модель model.

Расширения

Этот метод должен быть реализован в AbstractModel.

Пример

julia> model = Model();

julia> show_backend_summary(stdout, model)
Model mode: AUTOMATIC
CachingOptimizer state: NO_OPTIMIZER
Solver name: No optimizer attached.

# JuMP.show_constraints_summary — Method

show_constraints_summary(io::IO, model::AbstractModel)

Записывает в поток io сводку по количеству ограничений.

Расширения

Этот метод должен быть реализован в AbstractModel.

Пример

julia> model = Model();

julia> @variable(model, x >= 0);

julia> show_constraints_summary(stdout, model)
`VariableRef`-in-`MathOptInterface.GreaterThan{Float64}`: 1 constraint

# JuMP.show_objective_function_summary — Method

show_objective_function_summary(io::IO, model::AbstractModel)

Записывает в поток io сводку по типу целевой функции.

Расширения

Этот метод должен быть реализован в AbstractModel.

Пример

julia> model = Model();

julia> show_objective_function_summary(stdout, model)
Objective function type: AffExpr

# JuMP.simplex_iterations — Method

simplex_iterations(model::GenericModel)

Если доступно, возвращает совокупное количество симплексных итераций во время последней оптимизации (атрибут MOI.SimplexIterations).

Если этот атрибут не реализован решателем, выдает ошибку MOI.GetAttributeNotAllowed.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> optimize!(model)

julia> simplex_iterations(model)
0

# JuMP.solution_summary — Method

solution_summary(model::GenericModel; result::Int = 1, verbose::Bool = false)

Возвращает структуру, которую можно использовать для вывода сводки по решению в результате result.

При verbose=true выводятся прямое решение для каждой переменной и двойственное решение для каждого ограничения, за исключением имеющих пустые имена.

Пример

При вызове в REPL сводка выводится автоматически:

julia> model = Model();

julia> solution_summary(model)
* Solver : No optimizer attached.

* Status
  Result count       : 0
  Termination status : OPTIMIZE_NOT_CALLED
  Message from the solver:
  "optimize not called"

* Candidate solution (result #1)
  Primal status      : NO_SOLUTION
  Dual status        : NO_SOLUTION

* Work counters

Используйте print для принудительного вывода сводки из функции:

julia> model = Model();

julia> function foo(model)
           print(solution_summary(model))
           return
       end
foo (generic function with 1 method)

julia> foo(model)
* Solver : No optimizer attached.

* Status
  Result count       : 0
  Termination status : OPTIMIZE_NOT_CALLED
  Message from the solver:
  "optimize not called"

* Candidate solution (result #1)
  Primal status      : NO_SOLUTION
  Dual status        : NO_SOLUTION

* Work counters

# JuMP.solve_time — Method

solve_time(model::GenericModel)

Возвращает физическое время решения в секундах, сообщенное решателем (атрибут MOI.SolveTimeSec), если оно доступно.

Если этот атрибут не реализован решателем, выдает ошибку MOI.GetAttributeNotAllowed.

Пример

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> optimize!(model)

julia> solve_time(model)
1.0488089174032211e-5

# JuMP.solver_name — Method

solver_name(model::GenericModel)

Возвращает свойство MOI.SolverName базового оптимизатора, если оно доступно.

Если оптимизатор не подключен, в режиме AUTOMATIC или MANUAL возвращает сообщение "No optimizer attached.".

Если атрибут не реализован, возвращает сообщение "SolverName() attribute not implemented by the optimizer.".

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> solver_name(model)
"Ipopt"

julia> model = Model();

julia> solver_name(model)
"No optimizer attached."

julia> model = Model(MOI.FileFormats.MPS.Model);

julia> solver_name(model)
"SolverName() attribute not implemented by the optimizer."

# JuMP.start_value — Method

start_value(con_ref::ConstraintRef)

Возвращает прямое начальное значение (MOI.ConstraintPrimalStart) ограничения con_ref.

Если прямое начальное значение не задано, start_value возвращает nothing.

См. также описание метода set_start_value.

Пример

julia> model = Model();

julia> @variable(model, x, start = 2.0);

julia> @constraint(model, c, [2x] in Nonnegatives())
c : [2 x] ∈ MathOptInterface.Nonnegatives(1)

julia> set_start_value(c, [4.0])

julia> start_value(c)
1-element Vector{Float64}:
 4.0

julia> set_start_value(c, nothing)

julia> start_value(c)

# JuMP.start_value — Method

start_value(v::GenericVariableRef)

Возвращает начальное значение (MOI.VariablePrimalStart) переменной v.

Обратите внимание: значение VariablePrimalStart иногда называют «началом MIP» или «мягким началом».

См. также описание методов has_start_value и set_start_value.

Пример

julia> model = Model();

julia> @variable(model, x, start = 1.5);

julia> @variable(model, y);

julia> has_start_value(x)
true

julia> has_start_value(y)
false

julia> start_value(x)
1.5

julia> set_start_value(y, 2.0)

julia> has_start_value(y)
true

julia> start_value(y)
2.0

# JuMP.termination_status — Method

termination_status(model::GenericModel)

Возвращает код MOI.TerminationStatusCode, описывающий причину остановки решателя (то есть атрибут MOI.TerminationStatus).

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> termination_status(model)
OPTIMIZE_NOT_CALLED::TerminationStatusCode = 0

# JuMP.time_limit_sec — Method

time_limit_sec(model::GenericModel)

Возвращает ограничение по времени (в секундах) для модели model.

Если ограничение не задано, возвращает nothing.

См. также описание методов set_time_limit_sec и unset_time_limit_sec.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> time_limit_sec(model)

julia> set_time_limit_sec(model, 60.0)

julia> time_limit_sec(model)
60.0

julia> unset_time_limit_sec(model)

julia> time_limit_sec(model)

# JuMP.triangle_vec — Method

triangle_vec(matrix::Matrix)

Возвращает верхний треугольник матрицы, объединенный в вектор в порядке, требуемом JuMP и MathOptInterface для множеств Triangle.

Пример

julia> model = Model();

julia> @variable(model, X[1:3, 1:3], Symmetric);

julia> @variable(model, t)
t

julia> @constraint(model, [t; triangle_vec(X)] in MOI.RootDetConeTriangle(3))
[t, X[1,1], X[1,2], X[2,2], X[1,3], X[2,3], X[3,3]] ∈ MathOptInterface.RootDetConeTriangle(3)

# JuMP.unfix — Method

unfix(v::GenericVariableRef)

Удаляет фиксирующее ограничение переменной.

Если его не существует, выдает ошибку.

См. также описание FixRef, is_fixed, fix_value и fix.

Пример

julia> model = Model();

julia> @variable(model, x == 1);

julia> is_fixed(x)
true

julia> unfix(x)

julia> is_fixed(x)
false

# JuMP.unregister — Method

unregister(model::GenericModel, key::Symbol)

Отменяет регистрацию имени key в model, чтобы можно было создать новую переменную, ограничение или выражение с тем же ключом.

Обратите внимание, что объект model[key] при этом не удаляется; удаляется только ссылка на model[key]. Чтобы удалить объект, вызовите также метод delete.

См. также описание методов delete и object_dictionary.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @variable(model, x)
ERROR: An object of name x is already attached to this model. If this
    is intended, consider using the anonymous construction syntax, for example,
    `x = @variable(model, [1:N], ...)` where the name of the object does
    not appear inside the macro.

    Alternatively, use `unregister(model, :x)` to first unregister
    the existing name from the model. Note that this will not delete the
    object; it will just remove the reference at `model[:x]`.

Stacktrace:
[...]

julia> num_variables(model)
1

julia> unregister(model, :x)

julia> @variable(model, x)
x

julia> num_variables(model)
2

# JuMP.unsafe_backend — Method

unsafe_backend(model::GenericModel)

Возвращает самый внутренний оптимизатор, связанный с моделью JuMP model.

Эту функцию следует использовать только опытным пользователям, которым нужен доступ к низкоуровневым возможностям решателя. Существует большой риск ее неправильного использования. Настоятельно рекомендуем воспользоваться предложенной ниже альтернативой.

См. также описание метода backend.

Чтобы получить индекс переменной или ограничения в небезопасном бэкенде, используйте метод optimizer_index.

Небезопасное поведение

Эта функция небезопасна по двум основным причинам.

Во-первых, формулировка и порядок переменных и ограничений в небезопасном бэкенде могут отличаться от используемых в модели model. Причиной могут быть мосты или то, что решателю требуется определенный порядок переменных или ограничений. Помимо этого, индекс переменной или ограничения, возвращаемый методом index на уровне JuMP, может отличаться от индекса соответствующей переменной или ограничения в unsafe_backend. Решить эту проблему невозможно. Вместо этого используйте предложенную ниже альтернативу.

Во-вторых, бэкенд unsafe_backend может быть пустым или не содержать некоторых изменений, внесенных в модель JuMP. Поэтому перед вызовом unsafe_backend следует сначала вызвать MOI.Utilities.attach_optimizer, чтобы убедиться в том, что бэкенд синхронизирован с моделью JuMP.

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer)
A JuMP Model
Feasibility problem with:
Variables: 0
Model mode: AUTOMATIC
CachingOptimizer state: EMPTY_OPTIMIZER
Solver name: HiGHS

julia> MOI.Utilities.attach_optimizer(model)

julia> inner = unsafe_backend(model)
A HiGHS model with 0 columns and 0 rows.

Более того, если вы измените модель JuMP, ссылка на бэкенд (то есть inner в примере выше) может устареть и вам придется вызвать MOI.Utilities.attach_optimizer еще раз.

Эта функция небезопасна и в обратном направлении: если вы измените небезопасный бэкенд, например, добавив новое ограничение в inner, эти изменения могут быть отклонены JuMP без уведомления при изменении или решении модели JuMP model.

Альтернативный способ

Вместо unsafe_backend создайте модель с помощью direct_model](api.md#JuMP.direct_model-Tuple{MathOptInterface.ModelLike}) и вызовите [backend.

Например, вместо следующего кода:

julia> import HiGHS

julia> model = Model(HiGHS.Optimizer);

julia> set_silent(model)

julia> @variable(model, x >= 0)
x

julia> MOI.Utilities.attach_optimizer(model)

julia> highs = unsafe_backend(model)
A HiGHS model with 1 columns and 0 rows.

julia> optimizer_index(x)
MOI.VariableIndex(1)

Используйте такой:

julia> import HiGHS

julia> model = direct_model(HiGHS.Optimizer());

julia> set_silent(model)

julia> @variable(model, x >= 0)
x

julia> highs = backend(model)  # Не нужно вызывать `attach_optimizer`.
A HiGHS model with 1 columns and 0 rows.

julia> index(x)
MOI.VariableIndex(1)

# JuMP.unset_binary — Method

unset_binary(variable_ref::GenericVariableRef)

Удаляет ограничение двоичности для переменной variable_ref.

См. также описание BinaryRef, is_binary и set_binary.

Пример

julia> model = Model();

julia> @variable(model, x, Bin);

julia> is_binary(x)
true

julia> unset_binary(x)

julia> is_binary(x)
false

# JuMP.unset_integer — Method

unset_integer(variable_ref::GenericVariableRef)

Удаляет ограничение целостности для переменной variable_ref.

Если его не существует, выдает ошибку.

См. также описание IntegerRef, is_integer и set_integer.

Пример

julia> model = Model();

julia> @variable(model, x, Int);

julia> is_integer(x)
true

julia> unset_integer(x)

julia> is_integer(x)
false

# JuMP.unset_silent — Method

unset_silent(model::GenericModel)

Нейтрализует эффект функции set_silent, передавая контроль над уровнем детализации атрибутам решателя.

См. также описание метода set_silent.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> set_silent(model)

julia> get_attribute(model, MOI.Silent())
true

julia> unset_silent(model)

julia> get_attribute(model, MOI.Silent())
false

# JuMP.unset_time_limit_sec — Method

unset_time_limit_sec(model::GenericModel)

Снимает ограничение по времени для решателя.

См. также описание методов set_time_limit_sec и time_limit_sec.

Пример

julia> import Ipopt

julia> model = Model(Ipopt.Optimizer);

julia> time_limit_sec(model)

julia> set_time_limit_sec(model, 60.0)

julia> time_limit_sec(model)
60.0

julia> unset_time_limit_sec(model)

julia> time_limit_sec(model)

# JuMP.upper_bound — Method

upper_bound(v::GenericVariableRef)

Возвращает верхнюю границу переменной.

Если ее не существует, выдает ошибку.

См. также описание UpperBoundRef, has_upper_bound, set_upper_bound и delete_upper_bound.

Пример

julia> model = Model();

julia> @variable(model, x <= 1.0);

julia> upper_bound(x)
1.0

# JuMP.value — Method

value(con_ref::ConstraintRef; result::Int = 1)

Возвращает прямое значение ограничения con_ref, связанное с индексом результата result самого последнего решения, возвращенного решателем.

То есть если con_ref — это ссылка на ограничение «func в set», возвращается значение func, вычисленное по значению переменных (заданному посредством value(::GenericVariableRef)).

Чтобы проверить, существует ли результат, прежде чем запрашивать значения, используйте метод has_values.

См. также описание метода result_count.

Примечание

Для скалярных ограничений свободный член переносится в set и поэтому не учитывается в прямом значении ограничения. Например, ограничение @constraint(model, 2x + 3y + 1 == 5) преобразуется в «2x + 3y в MOI.EqualTo(4)», поэтому возвращаемое этой функцией значение является результатом вычисления 2x + 3y.

# JuMP.value — Method

value(var_value::Function, con_ref::ConstraintRef)

Вычисляет прямое значение ограничения con_ref, используя var_value(v) в качестве значения для каждой переменной v.

# JuMP.value — Method

value(var_value::Function, v::GenericVariableRef)

Вычисляет значение переменной v как var_value(v).

# JuMP.value — Method

value(var_value::Function, c::NonlinearConstraintRef)

Вычисляет c, используя var_value(v) в качестве значения для каждой переменной v.

# JuMP.value — Method

value(var_value::Function, ex::NonlinearExpression)

Вычисляет ex, используя var_value(v) в качестве значения для каждой переменной v.

# JuMP.value — Method

value(v::GenericAffExpr; result::Int = 1)

Возвращает значение GenericAffExpr v, связанное с индексом результата result самого последнего решения, возвращенного решателем.

См. также описание метода result_count.

# JuMP.value — Method

value(v::GenericQuadExpr; result::Int = 1)

Возвращает значение GenericQuadExpr v, связанное с индексом результата result самого последнего решения, возвращенного решателем.

В большинстве случаев использования заменяет getvalue.

См. также описание метода result_count.

# JuMP.value — Method

value(c::NonlinearConstraintRef; result::Int = 1)

Возвращает значение NonlinearConstraintRef c, связанное с индексом результата result самого последнего решения, возвращенного решателем.

См. также описание метода result_count.

# JuMP.value — Method

value(ex::NonlinearExpression; result::Int = 1)

Возвращает значение NonlinearExpression ex, связанное с индексом результата result самого последнего решения, возвращенного решателем.

См. также описание метода result_count.

# JuMP.value — Method

value(p::NonlinearParameter)

Возвращает текущее значение, хранящееся в нелинейном параметре p.

Пример

julia> model = Model();

julia> @NLparameter(model, p == 10)
p == 10.0

julia> value(p)
10.0

# JuMP.value — Method

value(v::GenericVariableRef; result = 1)

Возвращает значение переменной v, связанное с индексом результата result самого последнего решения, возвращенного решателем.

Чтобы проверить, существует ли результат, прежде чем запрашивать значения, используйте метод has_values.

См. также описание метода result_count.

# JuMP.value — Method

value(var_value::Function, ex::GenericQuadExpr)

Вычисляет ex, используя var_value(v) в качестве значения для каждой переменной v.

# JuMP.value — Method

value(var_value::Function, ex::GenericAffExpr)

Вычисляет ex, используя var_value(v) в качестве значения для каждой переменной v.

# JuMP.value_type — Method

value_type(::Type{<:Union{AbstractModel,AbstractVariableRef}})

Возвращает возвращаемый тип value переменных модели. Если тип не реализован, по умолчанию используется Float64.

Пример

julia> value_type(GenericModel{BigFloat})
BigFloat

# JuMP.variable_by_name — Method

variable_by_name(
    model::AbstractModel,
    name::String,
)::Union{AbstractVariableRef,Nothing}

Возвращает ссылку на переменную с атрибутом имени name или Nothing, если ни у одной переменной нет такого атрибута имени. Если несколько переменных имеют атрибут имени name, выдает ошибку.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> variable_by_name(model, "x")
x

julia> @variable(model, base_name="x")
x

julia> variable_by_name(model, "x")
ERROR: Multiple variables have the name x.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] get(::MOIU.Model{Float64}, ::Type{MathOptInterface.VariableIndex}, ::String) at /home/blegat/.julia/dev/MathOptInterface/src/Utilities/model.jl:222
 [3] get at /home/blegat/.julia/dev/MathOptInterface/src/Utilities/universalfallback.jl:201 [inlined]
 [4] get(::MathOptInterface.Utilities.CachingOptimizer{MathOptInterface.AbstractOptimizer,MathOptInterface.Utilities.UniversalFallback{MOIU.Model{Float64}}}, ::Type{MathOptInterface.VariableIndex}, ::String) at /home/blegat/.julia/dev/MathOptInterface/src/Utilities/cachingoptimizer.jl:490
 [5] variable_by_name(::GenericModel, ::String) at /home/blegat/.julia/dev/JuMP/src/variables.jl:268
 [6] top-level scope at none:0

julia> var = @variable(model, base_name="y")
y

julia> variable_by_name(model, "y")
y

julia> set_name(var, "z")

julia> variable_by_name(model, "y")

julia> variable_by_name(model, "z")
z

julia> @variable(model, u[1:2])
2-element Vector{VariableRef}:
 u[1]
 u[2]

julia> variable_by_name(model, "u[2]")
u[2]

# JuMP.variable_ref_type — Method

variable_ref_type(::Union{F,Type{F}}) where {F}

Вспомогательная функция, используемая внутри JuMP и некоторых расширений JuMP. Возвращает тип переменной, связанный с типом модели или выражения F.

# JuMP.vectorize — Function

vectorize(matrix::AbstractMatrix, ::Shape)

Преобразует matrix в вектор в соответствии с Shape.

# JuMP.write_to_file — Method

write_to_file(
    model::GenericModel,
    filename::String;
    format::MOI.FileFormats.FileFormat = MOI.FileFormats.FORMAT_AUTOMATIC,
    kwargs...,
)

Записывает модель JuMP model в filename в формате format.

Если имя файла заканчивается на .gz, он сжимается с помощью GZip. Если имя файла заканчивается на .bz2, он сжимается с помощью BZip2.

Другие аргументы kwargs передаются в конструктор Model выбранного формата.

# MathOptInterface.Utilities.attach_optimizer — Method

MOIU.attach_optimizer(model::GenericModel)

Вызывает MOIU.attach_optimizer для бэкенда модели model.

Нельзя вызывать в прямом режиме.

# MathOptInterface.Utilities.drop_optimizer — Method

MOIU.drop_optimizer(model::GenericModel)

Вызывает MOIU.drop_optimizer для бэкенда модели model.

Нельзя вызывать в прямом режиме.

# MathOptInterface.Utilities.reset_optimizer — Function

MOIU.reset_optimizer(model::GenericModel, optimizer::MOI.AbstractOptimizer)

Вызывает MOIU.reset_optimizer для бэкенда модели model.

Нельзя вызывать в прямом режиме.

# MathOptInterface.Utilities.reset_optimizer — Method

MOIU.reset_optimizer(model::GenericModel)

Вызывает MOIU.reset_optimizer для бэкенда модели model.

Нельзя вызывать в прямом режиме.

# MathOptInterface.get — Method

get(model::GenericModel, attr::MathOptInterface.AbstractModelAttribute)

Возвращает значение атрибута attr из бэкенда MOI модели.

# MathOptInterface.get — Method

get(model::GenericModel, attr::MathOptInterface.AbstractOptimizerAttribute)

Возвращает значение атрибута attr из бэкенда MOI модели.

# JuMP.@NLconstraint — Macro

@NLconstraint(model::GenericModel, expr)

Добавляет ограничение, описываемое нелинейным выражением expr. См. также описание макроса @constraint.

Совместимость

Этот макрос является частью устаревшего нелинейного интерфейса. Рекомендуется использовать новый нелинейный интерфейс, который описывается в разделе Nonlinear Modeling. В большинстве случаев @NLconstraint можно заменить на @constraint.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @NLconstraint(model, sin(x) <= 1)
sin(x) - 1.0 ≤ 0

julia> @NLconstraint(model, [i = 1:3], sin(i * x) <= 1 / i)
3-element Vector{NonlinearConstraintRef{ScalarShape}}:
 (sin(1.0 * x) - 1.0 / 1.0) - 0.0 ≤ 0
 (sin(2.0 * x) - 1.0 / 2.0) - 0.0 ≤ 0
 (sin(3.0 * x) - 1.0 / 3.0) - 0.0 ≤ 0

# JuMP.@NLconstraints — Macro

@NLconstraints(model, args...)

Добавляет в модель сразу несколько нелинейных ограничений так же, как это делает макрос @NLconstraint.

Модель должна быть первым аргументом, а несколько ограничений можно добавить в нескольких строках, заключенных в блок begin ... end.

Макрос возвращает кортеж с определенными ограничениями.

Совместимость

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @variable(model, y);

julia> @variable(model, t);

julia> @variable(model, z[1:2]);

julia> a = [4, 5];

julia> @NLconstraints(model, begin
           t >= sqrt(x^2 + y^2)
           [i = 1:2], z[i] <= log(a[i])
       end)
((t - sqrt(x ^ 2.0 + y ^ 2.0)) - 0.0 ≥ 0, NonlinearConstraintRef{ScalarShape}[(z[1] - log(4.0)) - 0.0 ≤ 0, (z[2] - log(5.0)) - 0.0 ≤ 0])

# JuMP.@NLexpression — Macro

@NLexpression(args...)

Эффективно создает нелинейное выражение, которое затем можно вставить в другие нелинейные ограничения и целевую функцию. См. также описание макроса @expression.

Совместимость

Этот макрос является частью устаревшего нелинейного интерфейса. Рекомендуется использовать новый нелинейный интерфейс, который описывается в разделе Nonlinear Modeling. В большинстве случаев @NLexpression можно заменить на @expression.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @variable(model, y)
y

julia> @NLexpression(model, my_expr, sin(x)^2 + cos(x^2))
subexpression[1]: sin(x) ^ 2.0 + cos(x ^ 2.0)

julia> @NLconstraint(model, my_expr + y >= 5)
(subexpression[1] + y) - 5.0 ≥ 0

julia> @NLobjective(model, Min, my_expr)

Также поддерживается индексирование множеств и анонимных выражений:

julia> @NLexpression(model, my_expr_1[i=1:3], sin(i * x))
3-element Vector{NonlinearExpression}:
 subexpression[2]: sin(1.0 * x)
 subexpression[3]: sin(2.0 * x)
 subexpression[4]: sin(3.0 * x)

julia> my_expr_2 = @NLexpression(model, log(1 + sum(exp(my_expr_1[i]) for i in 1:2)))
subexpression[5]: log(1.0 + (exp(subexpression[2]) + exp(subexpression[3])))

# JuMP.@NLexpressions — Macro

@NLexpressions(model, args...)

Добавляет в модель сразу несколько нелинейных выражений так же, как это делает макрос @NLexpression.

Модель должна быть первым аргументом, а несколько выражений можно добавить в нескольких строках, заключенных в блок begin ... end.

Макрос возвращает кортеж с определенными выражениями.

Совместимость

Этот макрос является частью устаревшего нелинейного интерфейса. Рекомендуется использовать новый нелинейный интерфейс, который описывается в разделе Nonlinear Modeling. В большинстве случаев @NLexpressions можно заменить на @expressions.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @variable(model, y);

julia> @variable(model, z[1:2]);

julia> a = [4, 5];

julia> @NLexpressions(model, begin
           my_expr, sqrt(x^2 + y^2)
           my_expr_1[i = 1:2], log(a[i]) - z[i]
       end)
(subexpression[1]: sqrt(x ^ 2.0 + y ^ 2.0), NonlinearExpression[subexpression[2]: log(4.0) - z[1], subexpression[3]: log(5.0) - z[2]])

# JuMP.@NLobjective — Macro

@NLobjective(model, sense, expression)

Добавляет нелинейную целевую функцию в model с назначением оптимизации sense. Аргумент sense должен иметь значение Max или Min.

Совместимость

Этот макрос является частью устаревшего нелинейного интерфейса. Рекомендуется использовать новый нелинейный интерфейс, который описывается в разделе Nonlinear Modeling. В большинстве случаев @NLobjective можно заменить на @objective.

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> @NLobjective(model, Max, 2x + 1 + sin(x))

julia> print(model)
Max 2.0 * x + 1.0 + sin(x)
Subject to

# JuMP.@NLparameter — Macro

@NLparameter(model, param == value)

Создает и возвращает нелинейный параметр param, связанный с моделью model, с начальным значением value. Нелинейные параметры можно использовать только в нелинейных выражениях.

Пример

julia> model = Model();

julia> @NLparameter(model, x == 10)
x == 10.0

julia> value(x)
10.0

@NLparameter(model, value = param_value)

Создает и возвращает анонимный нелинейный параметр param, связанный с моделью model, с начальным значением param_value. Нелинейные параметры можно использовать только в нелинейных выражениях.

Пример

julia> model = Model();

julia> x = @NLparameter(model, value = 10)
parameter[1] == 10.0

julia> value(x)
10.0

@NLparameter(model, param_collection[...] == value_expr)

Создает и возвращает коллекцию нелинейных параметров param_collection, связанную с моделью model, с начальным значением value_expr (может зависеть от множеств индексов). Для указания множеств индексов использует тот же синтаксис, что и @variable.

Пример

julia> model = Model();

julia> @NLparameter(model, y[i = 1:3] == 2 * i)
3-element Vector{NonlinearParameter}:
 parameter[1] == 2.0
 parameter[2] == 4.0
 parameter[3] == 6.0

julia> value(y[2])
4.0

@NLparameter(model, [...] == value_expr)

Создает и возвращает анонимную коллекцию нелинейных параметров, связанную с моделью model, с начальным значением value_expr (может зависеть от множеств индексов). Для указания множеств индексов использует тот же синтаксис, что и @variable.

Совместимость

Этот макрос является частью устаревшего нелинейного интерфейса. Рекомендуется использовать новый нелинейный интерфейс, который описывается в разделе Nonlinear Modeling. В большинстве случаев вызов наподобие @NLparameter(model, p == value) можно заменить на @variable(model, p in Parameter(value)).

Пример

julia> model = Model();

julia> y = @NLparameter(model, [i = 1:3] == 2 * i)
3-element Vector{NonlinearParameter}:
 parameter[1] == 2.0
 parameter[2] == 4.0
 parameter[3] == 6.0

julia> value(y[2])
4.0

# JuMP.@NLparameters — Macro

 @NLparameters(model, args...)

Создает и возвращает несколько нелинейных параметров, связанных с моделью model, так же, как это делает макрос @NLparameter.

Модель должна быть первым аргументом, а несколько параметров можно добавить в нескольких строках, заключенных в блок begin ... end. Отдельные параметры должны находиться в отдельных строках, как в следующем примере.

Макрос возвращает кортеж с определенными параметрами.

Совместимость

@NLparameters(model, begin
p == value
end)

можно заменить на

@variables(model, begin
p in Parameter(value)
end)

Пример

julia> model = Model();

julia> @NLparameters(model, begin
           x == 10
           b == 156
       end);

julia> value(x)
10.0

# JuMP.@build_constraint — Macro

@build_constraint(constraint_expr)

Создает ограничение ScalarConstraint или VectorConstraint, используя тот же механизм, что и макрос @constraint, но не добавляет ограничение в модель.

Ограничения, использующие операторы трансляции, например x .<= 1, также поддерживаются и создают массивы ограничений ScalarConstraint или VectorConstraint.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @build_constraint(2x >= 1)
ScalarConstraint{AffExpr, MathOptInterface.GreaterThan{Float64}}(2 x, MathOptInterface.GreaterThan{Float64}(1.0))

julia> model = Model();

julia> @variable(model, x[1:2]);

julia> @build_constraint(x .>= 0)
2-element Vector{ScalarConstraint{AffExpr, MathOptInterface.GreaterThan{Float64}}}:
 ScalarConstraint{AffExpr, MathOptInterface.GreaterThan{Float64}}(x[1], MathOptInterface.GreaterThan{Float64}(-0.0))
 ScalarConstraint{AffExpr, MathOptInterface.GreaterThan{Float64}}(x[2], MathOptInterface.GreaterThan{Float64}(-0.0))

# JuMP.@constraint — Macro

@constraint(model, expr, args...; kwargs...)
@constraint(model, [index_sets...], expr, args...; kwargs...)
@constraint(model, name, expr, args...; kwargs...)
@constraint(model, name[index_sets...], expr, args...; kwargs...)

Добавляет ограничение, описываемое выражением expr.

Аргумент name является необязательным. Если передаются множества индексов, создается контейнер и ограничение может зависеть от индексов во множествах индексов.

Выражение expr может иметь одну из следующих форм:

func in set — функция func должна принадлежать множеству set, которое представляет собой либо MOI.AbstractSet, либо одну из сокращенных форм JuMP, например

SecondOrderCone or PSDCone
a <op> b, где <op> — это ==, ≥, >=, ≤ или <=;
l <= f <= u или u >= f >= l — выражение f должно находиться в диапазоне от l до u;
f(x) ⟂ x — определяет комплементарное ограничение;
z --> {expr} — определяет индикаторное ограничение, которое активируется, когда z равно 1;
!z --> {expr} — определяет индикаторное ограничение, которое активируется, когда z равно 0;
z <--> {expr} — определяет материализованное ограничение;
expr := rhs — определяет ограничение логического равенства.

Транслируемые операторы сравнения, такие как .==, также поддерживаются для случая, когда левая и правая части оператора сравнения являются массивами.

Расширения JuMP могут обеспечивать поддержку других выражений ограничений, которые здесь не перечислены.

Именованные аргументы

base_name: задает префикс имени, используемый для генерирования имен ограничений. Для скалярных ограничений соответствует имени ограничения; в противном случае имена ограничений будут равны base_name[...] для каждого индекса ....
container = :Auto: принудительно задает тип контейнера путем передачи container = Array, container = DenseAxisArray, container = SparseAxisArray или любого другого типа контейнера, поддерживаемого расширением JuMP.
set_string_name::Bool = true: определяет, следует ли устанавливать атрибут MOI.ConstraintName. Передача значения set_string_name = false позволяет повысить производительность.

Расширения JuMP могут поддерживать и другие именованные аргументы.

Пример

julia> model = Model();

julia> @variable(model, x[1:3]);

julia> @variable(model, z, Bin);

julia> @constraint(model, x in SecondOrderCone())
[x[1], x[2], x[3]] ∈ MathOptInterface.SecondOrderCone(3)

julia> @constraint(model, [i in 1:3], x[i] == i)
3-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, ScalarShape}}:
 x[1] = 1
 x[2] = 2
 x[3] = 3

julia> @constraint(model, x .== [1, 2, 3])
3-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, ScalarShape}}:
 x[1] = 1
 x[2] = 2
 x[3] = 3

julia> @constraint(model, con_name, 1 <= x[1] + x[2] <= 3)
con_name : x[1] + x[2] ∈ [1, 3]

julia> @constraint(model, con_perp[i in 1:3], x[i] - 1 ⟂ x[i])
3-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.VectorAffineFunction{Float64}, MathOptInterface.Complements}, VectorShape}}:
 con_perp[1] : [x[1] - 1, x[1]] ∈ MathOptInterface.Complements(2)
 con_perp[2] : [x[2] - 1, x[2]] ∈ MathOptInterface.Complements(2)
 con_perp[3] : [x[3] - 1, x[3]] ∈ MathOptInterface.Complements(2)

julia> @constraint(model, z --> {x[1] >= 0})
z --> {x[1] ≥ 0}

julia> @constraint(model, !z --> {2 * x[2] <= 3})
!z --> {2 x[2] ≤ 3}

# JuMP.@constraints — Macro

@constraints(model, args...)

Добавляет сразу несколько групп ограничений так же, как это делает макрос @constraint.

Макрос возвращает кортеж с определенными ограничениями.

Пример

julia> model = Model();

julia> @variable(model, w);

julia> @variable(model, x);

julia> @variable(model, y);

julia> @variable(model, z[1:3]);

julia> @constraints(model, begin
           x >= 1
           y - w <= 2
           sum_to_one[i=1:3], z[i] + y == 1
       end);

julia> print(model)
Feasibility
Subject to
 sum_to_one[1] : y + z[1] = 1
 sum_to_one[2] : y + z[2] = 1
 sum_to_one[3] : y + z[3] = 1
 x ≥ 1
 -w + y ≤ 2

# JuMP.@expression — Macro

@expression(model::GenericModel, expression)
@expression(model::GenericModel, [index_sets...], expression)
@expression(model::GenericModel, name, expression)
@expression(model::GenericModel, name[index_sets...], expression)

Эффективно создает и возвращает выражение.

Аргумент name является необязательным. Если передаются множества индексов, создается контейнер и выражение может зависеть от индексов во множествах индексов.

Именованные аргументы

container = :Auto: принудительно задает тип контейнера путем передачи container = Array, container = DenseAxisArray, container = SparseAxisArray или любого другого типа контейнера, поддерживаемого расширением JuMP.

Пример

julia> model = Model();

julia> @variable(model, x[1:5]);

julia> @expression(model, shared, sum(i * x[i] for i in 1:5))
x[1] + 2 x[2] + 3 x[3] + 4 x[4] + 5 x[5]

julia> shared
x[1] + 2 x[2] + 3 x[3] + 4 x[4] + 5 x[5]

Как и в случае с макросом @variable, во втором аргументе могут быть определены множества индексов, которые могут использоваться при построении выражений:

julia> model = Model();

julia> @variable(model, x[1:3]);

julia> @expression(model, expr[i = 1:3], i * sum(x[j] for j in 1:3))
3-element Vector{AffExpr}:
 x[1] + x[2] + x[3]
 2 x[1] + 2 x[2] + 2 x[3]
 3 x[1] + 3 x[2] + 3 x[3]

Также поддерживается анонимный синтаксис:

julia> model = Model();

julia> @variable(model, x[1:3]);

julia> expr = @expression(model, [i in 1:3], i * sum(x[j] for j in 1:3))
3-element Vector{AffExpr}:
 x[1] + x[2] + x[3]
 2 x[1] + 2 x[2] + 2 x[3]
 3 x[1] + 3 x[2] + 3 x[3]

# JuMP.@expressions — Macro

@expressions(model, args...)

Добавляет в модель сразу несколько выражений так же, как это делает макрос @expression.

Макрос возвращает кортеж с определенными выражениями.

Пример

julia> model = Model();

julia> @variable(model, x);

julia> @variable(model, y);

julia> @variable(model, z[1:2]);

julia> a = [4, 5];

julia> @expressions(model, begin
           my_expr, x^2 + y^2
           my_expr_1[i = 1:2], a[i] - z[i]
       end)
(x² + y², AffExpr[-z[1] + 4, -z[2] + 5])

# JuMP.@force_nonlinear — Macro

@force_nonlinear(expr)

Изменяет способ анализа выражения expr так, что создается GenericNonlinearExpr, а не GenericAffExpr или GenericQuadExpr.

Принцип работы этого макроса заключается в обходе expr и замене всех вызовов +, -, *, / и ^ на вызовы, в результате которых создается GenericNonlinearExpr.

Этот макрос выдает ошибку, если результирующее выражение не создает GenericNonlinearExpr, например, если он применяется к выражению, в котором не используются базовые арифметические операторы.

Когда следует использовать этот макрос

В большинстве случаев этот макрос не следует использовать.

Используйте его только в том случае, если предполагается тип вывода GenericNonlinearExpr, а обычные вызовы макросов разрушают структуру задачи, либо в тех редких случаях, когда в результате обычных вызовов макросов вводится множество промежуточных переменных, например из-за продвижения типов до общего квадратичного выражения.

Пример

Первый случай использования: сохранение структуры задачи.

julia> model = Model();

julia> @variable(model, x);

julia> @expression(model, (x - 0.1)^2)
x² - 0.2 x + 0.010000000000000002

julia> @expression(model, @force_nonlinear((x - 0.1)^2))
(x - 0.1) ^ 2

julia> (x - 0.1)^2
x² - 0.2 x + 0.010000000000000002

julia> @force_nonlinear((x - 0.1)^2)
(x - 0.1) ^ 2

Второй случай использования: сокращение выделяемой памяти.

В этом примере известно, что на основе x * 2.0 * (1 + x) * x будет построено нелинейное выражение.

Однако в результате анализа по умолчанию сначала создаются следующие выражения:

GenericAffExpr a = x * 2.0;
еще одно выражение GenericAffExpr b = 1 + x;
GenericQuadExpr c = a * b;
GenericNonlinearExpr *(c, x).

В свою очередь, при модифицированном анализе создаются следующие выражения:

GenericNonlinearExpr a = GenericNonlinearExpr(:+, 1, x);
GenericNonlinearExpr GenericNonlinearExpr(:*, x, 2.0, a, x).

В результате выделяется гораздо меньше памяти.

julia> model = Model();

julia> @variable(model, x);

julia> @expression(model, x * 2.0 * (1 + x) * x)
(2 x² + 2 x) * x

julia> @expression(model, @force_nonlinear(x * 2.0 * (1 + x) * x))
x * 2.0 * (1 + x) * x

julia> @allocated @expression(model, x * 2.0 * (1 + x) * x)
3200

julia> @allocated @expression(model, @force_nonlinear(x * 2.0 * (1 + x) * x))
640

# JuMP.@objective — Macro

@objective(model::GenericModel, sense, func)

Устанавливает целевое назначение равным sense, а целевую функцию равной func.

Целевое назначение может иметь значение Min, Max, MOI.MIN_SENSE, MOI.MAX_SENSE или MOI.FEASIBILITY_SENSE. Чтобы задать назначение программным путем, то есть когда sense — это переменная, значением которой является назначение, необходимо использовать одно из трех значений MOI.OptimizationSense.

Пример

Минимизация значения переменной x:

julia> model = Model();

julia> @variable(model, x)
x

julia> @objective(model, Min, x)
x

Максимизация значения аффинного выражения 2x - 1:

julia> model = Model();

julia> @variable(model, x)
x

julia> @objective(model, Max, 2x - 1)
2 x - 1

Задаем целевое назначение программным путем:

julia> model = Model();

julia> @variable(model, x)
x

julia> sense = MIN_SENSE
MIN_SENSE::OptimizationSense = 0

julia> @objective(model, sense, x^2 - 2x + 1)
x² - 2 x + 1

# JuMP.@operator — Macro

@operator(model, operator, dim, f[, ∇f[, ∇²f]])

Добавляет нелинейный оператор operator в модель model с dim аргументов и создает новый объект NonlinearOperator с именем operator в текущей области.

Функция f вычисляет оператор и должна возвращать скалярное значение.

Функцию ∇²f можно передать только в том случае, если передана функция ∇f.

Одномерный синтаксис

При dim == 1 сигнатуры методов каждой функции должны быть следующими:

f(::T)::T where {T<:Real}
∇f(::T)::T where {T<:Real}
∇²f(::T)::T where {T<:Real}

Многомерный синтаксис

При dim > 1 сигнатуры методов каждой функции должны быть следующими:

f(x::T...)::T where {T<:Real}
∇f(g::AbstractVector{T}, x::T...)::Nothing where {T<:Real}
∇²f(H::AbstractMatrix{T}, x::T...)::Nothing where {T<:Real}

Пример

julia> model = Model();

julia> @variable(model, x)
x

julia> f(x::Float64) = x^2
f (generic function with 1 method)

julia> ∇f(x::Float64) = 2 * x
∇f (generic function with 1 method)

julia> ∇²f(x::Float64) = 2.0
∇²f (generic function with 1 method)

julia> @operator(model, op_f, 1, f, ∇f, ∇²f)
NonlinearOperator(f, :op_f)

julia> @objective(model, Min, op_f(x))
op_f(x)

julia> op_f(2.0)
4.0

julia> model[:op_f]
NonlinearOperator(f, :op_f)

julia> model[:op_f](x)
op_f(x)

Версия без макроса

Этот макрос обеспечивает удобный синтаксис, согласующийся со стилем остальных макросов JuMP. Однако операторы можно добавлять и без использования макроса с помощью метода add_nonlinear_operator. Например:

julia> model = Model();

julia> f(x) = x^2
f (generic function with 1 method)

julia> @operator(model, op_f, 1, f)
NonlinearOperator(f, :op_f)

эквивалентно

julia> model = Model();

julia> f(x) = x^2
f (generic function with 1 method)

julia> op_f = model[:op_f] = add_nonlinear_operator(model, 1, f; name = :op_f)
NonlinearOperator(f, :op_f)

# JuMP.@variable — Macro

@variable(model, expr, args..., kw_args...)

Добавляет в модель model переменную, описываемую выражением expr, позиционными аргументами args и именованными аргументами kw_args.

Анонимные и именованные переменные

Выражение expr должно иметь одну из следующих форм:

пропущено (например, @variable(model)); при этом создается анонимная переменная;
одиночный символ, например @variable(model, x);
выражение контейнера, например @variable(model, x[i=1:3]);
анонимное выражение контейнера, например @variable(model, [i=1:3]).

Границы

Помимо этого, выражение может иметь границы, например:

@variable(model, x >= 0)
@variable(model, x <= 0)
@variable(model, x == 0)
@variable(model, 0 <= x <= 1)

Границы могут зависеть от индексов выражения контейнера:

@variable(model, -i <= x[i=1:3] <= i)

Множества

Вы можете явным образом указать множество, которому принадлежит переменная:

@variable(model, x in MOI.Interval(0.0, 1.0))

Дополнительные сведения об этом синтаксисе см. в разделе Variables constrained on creation.

Позиционные аргументы

В args распознаются следующие позиционные аргументы:

Bin: ограничивает переменную множеством MOI.ZeroOne, то есть {0, 1}. Например, @variable(model, x, Bin). Обратите внимание: вызов @variable(model, Bin) недопустим; используйте вместо этого именованный аргумент binary.
Int: ограничивает переменную множеством целых чисел, то есть …, -2, -1,

0, 1, 2, … Например, @variable(model, x, Int). Обратите внимание: вызов @variable(model, Int) недопустим; используйте вместо этого именованный аргумент integer.

Symmetric: доступен только при создании квадратной матрицы переменных, то есть когда expr имеет вид varname[1:n,1:n] или varname[i=1:n,j=1:n], создается симметричная матрица переменных.
PSD: ограничительное расширение Symmetric, которое ограничивает квадратную матрицу переменных формой Symmetric, а ограничения — положительно полуопределенной формой.

Именованные аргументы

При любых условиях полезны четыре именованных аргумента:

base_name: задает префикс имени, используемый для генерирования имен переменных. Для скалярных переменных соответствует имени переменной; в противном случае имена переменных будут равны base_name[...] для каждого индекса ... по осям axes.
start::Float64: определяет передаваемое в set_start_value значение для каждой переменной.
container: задает тип контейнера. Дополнительные сведения см. в разделе Принудительное задание типа контейнера.
set_string_name::Bool = true: определяет, следует ли устанавливать атрибут MOI.VariableName attribute. Passing set_string_name = false can повысить производительность.

Другие именованные аргументы необходимы для устранения неоднозначности анонимных переменных:

lower_bound::Float64: альтернатива для x >= lb; задает значение нижней границы переменной.
upper_bound::Float64: альтернатива для x <= ub; задает значение верхней границы переменной.
binary::Bool: альтернатива передаче Bin; указывает, является ли переменная двоичной.
integer::Bool: альтернатива передаче Int; указывает, является ли переменная целочисленной.
set::MOI.AbstractSet: альтернатива использованию x in set.
variable_type: используется расширениями JuMP. Дополнительные сведения см. в разделе Расширение макроса @variable.

Пример

Ниже представлены эквивалентные способы создания переменной x с именем x и нижней границей 0:

julia> model = Model();

julia> @variable(model, x >= 0)
x

julia> model = Model();

julia> @variable(model, x, lower_bound = 0)
x

julia> model = Model();

julia> x = @variable(model, base_name = "x", lower_bound = 0)
x

Другие примеры:

julia> model = Model();

julia> @variable(model, x[i=1:3] <= i, Int, start = sqrt(i), lower_bound = -i)
3-element Vector{VariableRef}:
 x[1]
 x[2]
 x[3]

julia> @variable(model, y[i=1:3], container = DenseAxisArray, set = MOI.ZeroOne())
1-dimensional DenseAxisArray{VariableRef,1,...} with index sets:
    Dimension 1, Base.OneTo(3)
And data, a 3-element Vector{VariableRef}:
 y[1]
 y[2]
 y[3]

julia> @variable(model, z[i=1:3], set_string_name = false)
3-element Vector{VariableRef}:
 _[7]
 _[8]
 _[9]

# JuMP.@variables — Macro

@variables(model, args...)

Добавляет в модель сразу несколько переменных так же, как это делает макрос @variable.

Модель должна быть первым аргументом, а несколько переменных можно добавить в нескольких строках, заключенных в блок begin ... end.

Макрос возвращает кортеж с определенными переменными.

Пример

julia> model = Model();

julia> @variables(model, begin
           x
           y[i = 1:2] >= 0, (start = i)
           z, Bin, (start = 0, base_name = "Z")
       end)
(x, VariableRef[y[1], y[2]], Z)

Именованные аргументы должны быть заключены в скобки (см. пример выше).

# JuMP.TerminationStatusCode — Type

TerminationStatusCode

Перечисление возможных значений атрибута TerminationStatus. Этот атрибут описывает причину, по которой оптимизатор прекратил выполнение при последнем вызове optimize!.

Значения

Возможные значения:

OPTIMIZE_NOT_CALLED: The algorithm has not started.
OPTIMAL: The algorithm found a globally optimal solution.
INFEASIBLE: The algorithm concluded that no feasible solution exists.
DUAL_INFEASIBLE: The algorithm concluded that no dual bound exists for the problem. If, additionally, a feasible (primal) solution is known to exist, this status typically implies that the problem is unbounded, with some technical exceptions.
LOCALLY_SOLVED: The algorithm converged to a stationary point, local optimal solution, could not find directions for improvement, or otherwise completed its search without global guarantees.
LOCALLY_INFEASIBLE: The algorithm converged to an infeasible point or otherwise completed its search without finding a feasible solution, without guarantees that no feasible solution exists.
INFEASIBLE_OR_UNBOUNDED: The algorithm stopped because it decided that the problem is infeasible or unbounded; this occasionally happens during MIP presolve.
ALMOST_OPTIMAL: The algorithm found a globally optimal solution to relaxed tolerances.
ALMOST_INFEASIBLE: The algorithm concluded that no feasible solution exists within relaxed tolerances.
ALMOST_DUAL_INFEASIBLE: The algorithm concluded that no dual bound exists for the problem within relaxed tolerances.
ALMOST_LOCALLY_SOLVED: The algorithm converged to a stationary point, local optimal solution, or could not find directions for improvement within relaxed tolerances.
ITERATION_LIMIT: An iterative algorithm stopped after conducting the maximum number of iterations.
TIME_LIMIT: The algorithm stopped after a user-specified computation time.
NODE_LIMIT: A branch-and-bound algorithm stopped because it explored a maximum number of nodes in the branch-and-bound tree.
SOLUTION_LIMIT: The algorithm stopped because it found the required number of solutions. This is often used in MIPs to get the solver to return the first feasible solution it encounters.
MEMORY_LIMIT: The algorithm stopped because it ran out of memory.
OBJECTIVE_LIMIT: The algorithm stopped because it found a solution better than a minimum limit set by the user.
NORM_LIMIT: The algorithm stopped because the norm of an iterate became too large.
OTHER_LIMIT: The algorithm stopped due to a limit not covered by one of the LIMIT statuses above.
SLOW_PROGRESS: The algorithm stopped because it was unable to continue making progress towards the solution.
NUMERICAL_ERROR: The algorithm stopped because it encountered unrecoverable numerical error.
INVALID_MODEL: The algorithm stopped because the model is invalid.
INVALID_OPTION: The algorithm stopped because it was provided an invalid option.
INTERRUPTED: The algorithm stopped because of an interrupt signal.
OTHER_ERROR: The algorithm stopped because of an error not covered by one of the statuses defined above.

# JuMP.ResultStatusCode — Type

ResultStatusCode

Перечисление возможных значений атрибутов PrimalStatus и DualStatus.

Значения указывают, как следует интерпретировать итоговый вектор.

Значения

Возможные значения:

NO_SOLUTION: the result vector is empty.
FEASIBLE_POINT: the result vector is a feasible point.
NEARLY_FEASIBLE_POINT: the result vector is feasible if some constraint tolerances are relaxed.
INFEASIBLE_POINT: the result vector is an infeasible point.
INFEASIBILITY_CERTIFICATE: the result vector is an infeasibility certificate. If the PrimalStatus is INFEASIBILITY_CERTIFICATE, then the primal result vector is a certificate of dual infeasibility. If the DualStatus is INFEASIBILITY_CERTIFICATE, then the dual result vector is a proof of primal infeasibility.
NEARLY_INFEASIBILITY_CERTIFICATE: the result satisfies a relaxed criterion for a certificate of infeasibility.
REDUCTION_CERTIFICATE: the result vector is an ill-posed certificate; see this article for details. If the PrimalStatus is REDUCTION_CERTIFICATE, then the primal result vector is a proof that the dual problem is ill-posed. If the DualStatus is REDUCTION_CERTIFICATE, then the dual result vector is a proof that the primal is ill-posed.
NEARLY_REDUCTION_CERTIFICATE: the result satisfies a relaxed criterion for an ill-posed certificate.
UNKNOWN_RESULT_STATUS: the result vector contains a solution with an unknown interpretation.
OTHER_RESULT_STATUS: the result vector contains a solution with an interpretation not covered by one of the statuses defined above

# JuMP.OptimizationSense — Type

OptimizationSense

Перечисление значений атрибута ObjectiveSense.

Значения

Возможные значения:

MIN_SENSE: the goal is to minimize the objective function
MAX_SENSE: the goal is to maximize the objective function
FEASIBILITY_SENSE: the model does not have an objective function

# JuMP.VariableRef — Type

GenericVariableRef{T} <: AbstractVariableRef

Содержит ссылку на модель и соответствующий MOI.VariableIndex.