शुरू करें

इस उदाहरण में MathOpt का इस्तेमाल करके एक सिंपल लीनियर प्रोग्राम (एलपी) को बनाने, हल करने, और उसके नतीजों को एक्सप्लोर करने का तरीका बताया गया है. OR-टूल इंस्टॉल करने के बारे में जानकारी इंस्टॉल गाइड में उपलब्ध है. सोर्स से बनाने और चलाने के तरीके के बारे में अतिरिक्त जानकारी, आखिर तक टाल दी जाती है.

MathOpt मॉडल बनाएं

आपके सोर्स में, आम तौर पर सिर्फ़ एक MathOpt डिपेंडेंसी जोड़ना ज़रूरी है:

Python

from ortools.math_opt.python import mathopt

C++

#include <iostream>
#include <ostream>

#include "absl/log/check.h"
#include "absl/status/statusor.h"
#include "ortools/base/init_google.h"
#include "ortools/math_opt/cpp/math_opt.h"

इस गाइड में, लीनियर प्रोग्रामिंग के इस सवाल का इस्तेमाल किया गया है और इसे जीएलओपी की मदद से हल किया गया है.

$$\begin{aligned} &\max &x + 2 \cdot y\\ &\text{subject to} &x + y &\leq 1.5 \\ &&-1 \leq x &\leq 1.5 \\ &&0 \leq y &\leq 1 \end{aligned}$$

सबसे पहले, मॉडल बनाएं:

Python

# Build the model.
model = mathopt.Model(name="getting_started_lp")
x = model.add_variable(lb=-1.0, ub=1.5, name="x")
y = model.add_variable(lb=0.0, ub=1.0, name="y")
model.add_linear_constraint(x + y <= 1.5)
model.maximize(x + 2 * y)

C++

// Build the model.
namespace math_opt = ::operations_research::math_opt;
math_opt::Model lp_model("getting_started_lp");
const math_opt::Variable x = lp_model.AddContinuousVariable(-1.0, 1.5, "x");
const math_opt::Variable y = lp_model.AddContinuousVariable(0.0, 1.0, "y");
lp_model.AddLinearConstraint(x + y <= 1.5, "c");
lp_model.Maximize(x + 2 * y);

समाधान को हल करना और हल करना

इसके बाद, सॉल्व के लिए पैरामीटर सेट करें. MathOpt की मदद से ऑप्टिमाइज़ेशन मॉडल को हल करना काफ़ी आसान होता है. इसमें सॉल्वर-इंडिपेंडेंट पैरामीटर (जैसे, चालू करें), सॉल्वर के लिए खास पैरामीटर (जैसे, Glopपैरामीटर. Optimization_Rule), मॉडल की प्रॉपर्टी (जैसे, ब्रांचिंग प्राथमिकता), सॉल्वर लॉग के लिए एक कॉलबैक, और ऑप्टिमाइज़ेशन को मॉनिटर और कंट्रोल करने के लिए कॉलबैक मौजूद हैं. ये पैरामीटर मौजूद होते हैं. यह कोड, सॉल्वर लॉग को चालू कर देता है.

Python

# Set parameters, e.g. turn on logging.
params = mathopt.SolveParameters(enable_output=True)

C++

// Set parameters, e.g. turn on logging.
math_opt::SolveArguments args;
args.parameters.enable_output = true;

जीएलओपी का इस्तेमाल करके, Google के सिंप्लेक्स-आधारित एलपी सॉल्वर का इस्तेमाल करके, Solve() फ़ंक्शन का इस्तेमाल करें.

Python

# Solve and ensure an optimal solution was found with no errors.
# (mathopt.solve may raise a RuntimeError on invalid input or internal solver
# errors.)
result = mathopt.solve(model, mathopt.SolverType.GLOP, params=params)
if result.termination.reason != mathopt.TerminationReason.OPTIMAL:
    raise RuntimeError(f"model failed to solve: {result.termination}")

C++

// Solve and ensure an optimal solution was found with no errors.
const absl::StatusOr<math_opt::SolveResult> result =
    math_opt::Solve(lp_model, math_opt::SolverType::kGlop, args);
CHECK_OK(result.status());
CHECK_OK(result->termination.EnsureIsOptimal());

आखिर में, सबसे सही समाधान और सबसे अच्छे वैरिएबल वैल्यू की मकसद वैल्यू की जांच करें. ध्यान दें कि सेशन को खत्म करने की वजह सबसे बेहतर थी, इसलिए यह मान लेना सुरक्षित है कि ये वैल्यू मौजूद हैं. हालांकि, समझौता खत्म करने की अन्य वजहों (जैसे, ऐक्सेस न किए जा सकने वाले या बिना किसी सीमा के) से इन तरीकों को CHECK fail (C++ में) या raise an exception (Python में) किया जा सकता है.

Python

# Print some information from the result.
print("MathOpt solve succeeded")
print("Objective value:", result.objective_value())
print("x:", result.variable_values()[x])
print("y:", result.variable_values()[y])

C++

// Print some information from the result.
std::cout << "MathOpt solve succeeded" << std::endl;
std::cout << "Objective value: " << result->objective_value() << std::endl;
std::cout << "x: " << result->variable_values().at(x) << std::endl;
std::cout << "y: " << result->variable_values().at(y) << std::endl;

Bazel का इस्तेमाल करके, कोड बनाने और चलाने के बारे में ज़रूरी जानकारी

अगर bazel का इस्तेमाल करके सोर्स से MathOpt बना रहे हैं, तो इस उदाहरण के लिए बिल्ड टारगेट में ये डिपेंडेंसी ज़रूरी हैं:

Python

"//util/operations_research/math_opt/python:mathopt"

C++

"//util/operations_research/math_opt/cpp:math_opt"
"//util/operations_research/math_opt/solvers:glop_solver"

आपका कोड चलाने के लिए, नीचे दिया गया बाज़ेल कमांड, आपके टारगेट को बनाता और चलाता है.

Python

bazel run path/to/you:target --with_scip=false --with_cp_sat=false
--with_glpk=false --with_glop=true -- --your_flags

C++

bazel run path/to/you:target -- --your_flags