JuMP extension added (#52)

* Made things compatible with ExaModelsMOI

* Null added

* Added docstrings

* Works for luksan instance

* Works for OPF, but need to address the scalability issue

* A bit dirty, but works

* added testing

* Testing and addressing Josh's comments

* Update readme

* Update documentation

* bug fix for affine objective

* prinft added

* Added utils

* Updated testing

* test should work now

* docstring updated

* md file clean up

* removed comment

* separated MOI

Author: sshin23

Project.toml

@@ -5,37 +5,42 @@ version = "0.4.2"
 
 [deps]
 NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"
+Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 SolverCore = "ff4d7338-4cf1-434d-91df-b86cb86fb843"
 
 [weakdeps]
+SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
+JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
+KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
 AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e"
 CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
-KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
-SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b"
+MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
 
 [extensions]
 ExaModelsAMDGPU = "AMDGPU"
 ExaModelsCUDA = "CUDA"
 ExaModelsKernelAbstractions = "KernelAbstractions"
 ExaModelsOneAPI = "oneAPI"
 ExaModelsSpecialFunctions = "SpecialFunctions"
+ExaModelsJuMP = "JuMP"
+ExaModelsMOI = "MathOptInterface"
 
 [compat]
-AMDGPU = "0.5"
-CUDA = "4"
+AMDGPU = "0.7"
+CUDA = "5"
 KernelAbstractions = "0.9"
 NLPModels = "0.18, 0.19, 0.20"
 SolverCore = "0.3"
 SpecialFunctions = "2"
 julia = "1.9"
 oneAPI = "1"
+MathOptInterface = "1.19"
 
 [extras]
 CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
-JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
 MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6"
 NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"

README.md

@@ -6,7 +6,7 @@
 
 | **License** | **Documentation** | **Build Status** | **Coverage** | **Citation** |
 |:-----------------:|:----------------:|:----------------:|:----------------:|:----------------:|
-| [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/sshin23/ExaModels.jl/blob/main/LICENSE) | [![doc](https://img.shields.io/badge/docs-stable-blue.svg)](https://sshin23.github.io/ExaModels.jl/stable) [![doc](https://img.shields.io/badge/docs-dev-blue.svg)](https://sshin23.github.io/ExaModels.jl/dev)  | [![build](https://github.com/sshin23/ExaModels.jl/actions/workflows/test.yml/badge.svg)](https://github.com/sshin23/ExaModels.jl/actions/workflows/test.yml) | [![codecov](https://codecov.io/gh/sshin23/ExaModels.jl/branch/main/graph/badge.svg?token=8ViJWBWnZt)](https://codecov.io/gh/sshin23/ExaModels.jl) | [![arXiv](https://img.shields.io/badge/arXiv-2307.16830-b31b1b.svg)](https://arxiv.org/abs/2307.16830) |
+| [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/exanauts/ExaModels.jl/blob/main/LICENSE) | [![doc](https://img.shields.io/badge/docs-stable-blue.svg)](https://exanauts.github.io/ExaModels.jl/stable) [![doc](https://img.shields.io/badge/docs-dev-blue.svg)](https://exanauts.github.io/ExaModels.jl/dev)  | [![build](https://github.com/exanauts/ExaModels.jl/actions/workflows/test.yml/badge.svg)](https://github.com/exanauts/ExaModels.jl/actions/workflows/test.yml) | [![codecov](https://codecov.io/gh/exanauts/ExaModels.jl/branch/main/graph/badge.svg?token=8ViJWBWnZt)](https://codecov.io/gh/exanauts/ExaModels.jl) | [![arXiv](https://img.shields.io/badge/arXiv-2307.16830-b31b1b.svg)](https://arxiv.org/abs/2307.16830) |
 
 ## Overview
 ExaModels.jl employs what we call **[SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) abstraction for [nonlinear programs](https://en.wikipedia.org/wiki/Nonlinear_programming)** (NLPs), which allows for the **preservation of the parallelizable structure** within the model equations, facilitating **efficient, parallel [reverse-mode automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation)** on the **[GPU](https://en.wikipedia.org/wiki/Graphics_processing_unit) accelerators**.
@@ -27,7 +27,7 @@ for double-precision arithmetic.
 
 ## Highlight
 The performance comparison of ExaModels with other algebraic modeling systems for evaluating different NLP functions (obj, con, grad, jac, and hess) are shown below. Note that Hessian computations are the typical bottlenecks.
-![benchmark](https://raw.githubusercontent.com/sshin23/ExaModels.jl/main/docs/src/assets/benchmark.svg)
+![benchmark](https://raw.githubusercontent.com/exanauts/ExaModels.jl/main/docs/src/assets/benchmark.svg)
 ## Supporting ExaModels.jl
-- Please report issues and feature requests via the [GitHub issue tracker](https://github.com/sshin/ExaModels.jl/issues).
-- Questions are welcome at [GitHub discussion forum](https://github.com/sshin23/ExaModels.jl/discussions).
+- Please report issues and feature requests via the [GitHub issue tracker](https://github.com/exanatus/ExaModels.jl/issues).
+- Questions are welcome at [GitHub discussion forum](https://github.com/exanauts/ExaModels.jl/discussions).

benchmark/Project.toml

@@ -32,7 +32,7 @@ ExaModelsBenchmarkKernelAbstractions = "KernelAbstractions"
 ExaModelsBenchmarkOneAPI = "oneAPI"
 
 [compat]
-AMDGPU = "0.5"
-CUDA = "4"
+AMDGPU = "0.7"
+CUDA = "5"
 KernelAbstractions = "0.9"
 oneAPI = "1"

docs/Project.toml

@@ -7,6 +7,7 @@ JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
 Literate = "98b081ad-f1c9-55d3-8b20-4c87d4299306"
 MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6"
+MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
 NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"
 NLPModelsIpopt = "f4238b75-b362-5c4c-b852-0801c9a21d71"
 PowerModels = "c36e90e8-916a-50a6-bd94-075b64ef4655"

docs/make.jl

@@ -10,6 +10,7 @@ if !(@isdefined _PAGES)
         "Mathematical Abstraction" => "simd.md",
         "Tutorial" => [
             "guide.md",
+            "jump.md",
             "performance.md",
             "gpu.md",
             "develop.md",
@@ -24,7 +25,7 @@ end
 
 if !(@isdefined _JL_FILENAMES)
     const _JL_FILENAMES =
-        ["guide.jl", "quad.jl", "distillation.jl", "opf.jl", "gpu.jl", "performance.jl"]
+        ["guide.jl", "jump.jl", "quad.jl", "distillation.jl", "opf.jl", "gpu.jl", "performance.jl"]
 end
 
 for jl_filename in _JL_FILENAMES
@@ -52,7 +53,7 @@ bib = CitationBibliography(joinpath(@__DIR__, "src", "refs.bib"))
 
 
 makedocs(
-    bib,
+    plugins=[bib],
     sitename = "ExaModels.jl",
     modules = [ExaModels],
     authors = "Sungho Shin",

docs/src/.gitignore

@@ -3,4 +3,5 @@ quad.md
 distillation.md
 opf.md
 gpu.md
-performance.md
+performance.md
+jump.md

docs/src/develop.md

@@ -2,7 +2,7 @@
 
 ExaModels.jl's API only uses simple julia funcitons, and thus, implementing the extensions is straightforward. Below, we suggest a good practice for implementing an extension package.
 
-Let's say that we want to implement an extension package for the example problem in [Getting Started](@ref). An extension package may look like:
+Let's say that we want to implement an extension package for the example problem in [Getting Started](@ref guide). An extension package may look like:
 ```
 Root
 ├───Project.toml

docs/src/distillation.jl

@@ -1,4 +1,4 @@
-# # Example: Distillation Column
+# # [Example: Distillation Column](@id distillation)
 
 function distillation_column_model(T = 3; backend = nothing)
 

docs/src/guide.jl

@@ -1,4 +1,4 @@
-# # Getting Started
+# # [Getting Started](@id guide)
 # ExaModels can create nonlinear prgogramming models and allows solving the created models using NLP solvers (in particular, those that are interfaced with `NLPModels`, such as [NLPModelsIpopt](https://github.com/JuliaSmoothOptimizers/NLPModelsIpopt.jl) and [MadNLP](https://github.com/MadNLP/MadNLP.jl). This documentation page will describe how to use `ExaModels` to model and solve nonlinear optimization problems.
 
 # We will first consider the following simple nonlinear program [lukvsan1998indefinitely](@cite):
@@ -10,11 +10,11 @@
 # ```
 # We will follow the following Steps to create the model/solve this optimization problem.
 # - Step 0: import ExaModels.jl
-# - Step 1: create a [`ExaCore`](@ref ExaCore) object, wherein we can progressively build an optimization model.
-# - Step 2: create optimization variables with [`variable`]((@ref variable)), while attaching it to previously created `ExaCore`.
-# - Step 3 (interchangable with Step 3): create objective function with [`objective`](@ref objective), while attaching it to previously created `ExaCore`.
-# - Step 4 (interchangable with Step 2): create constraints with [`constraint`](@ref constraint), while attaching it to previously created `ExaCore`.
-# - Step 5: create an [`ExaModel`](@ref ExaModel) based on the `ExaCore`.
+# - Step 1: create a [`ExaCore`](@ref) object, wherein we can progressively build an optimization model.
+# - Step 2: create optimization variables with [`variable`](@ref), while attaching it to previously created `ExaCore`.
+# - Step 3 (interchangable with Step 3): create objective function with [`objective`](@ref), while attaching it to previously created `ExaCore`.
+# - Step 4 (interchangable with Step 2): create constraints with [`constraint`](@ref), while attaching it to previously created `ExaCore`.
+# - Step 5: create an [`ExaModel`](@ref) based on the `ExaCore`.
 
 # Now, let's jump right in. We import ExaModels via (Step 0):
 using ExaModels
@@ -55,10 +55,10 @@ sol = solution(result, x)
 
 
 # ExaModels provide several APIs similar to this:
-# - [`solution`](@ref solution) inquires the primal solution.
-# - [`multiplier`](@ref multiplier) inquires the dual solution.
-# - [`multiplier_L`](@ref multiplier_L) inquires the lower bound dual solution.
-# - [`multiplier_U`](@ref multiplier_U) inquires the upper bound dual solution.
+# - [`solution`](@ref) inquires the primal solution.
+# - [`multipliers`](@ref) inquires the dual solution.
+# - [`multipliers_L`](@ref) inquires the lower bound dual solution.
+# - [`multipliers_U`](@ref) inquires the upper bound dual solution.
 
 # This concludes a short tutorial on how to use ExaModels to model and solve optimization problems. Want to learn more? Take a look at the following examples, which provide further tutorial on how to use ExaModels.jl. Each of the examples are designed to instruct a few additional techniques.
 # - [Example: Quadrotor](): modeling multiple types of objective values and constraints.

docs/src/index.md

@@ -8,7 +8,7 @@ Welcome to the documentation of [ExaModels.jl](https://github.com/sshin23/ExaMod
 	**Please help us improve ExaModels and this documentation!** ExaModels is in the early stage of development, and you may encounter unintended behaviors or missing documentations. If you find anything is not working as intended or documentation is missing, please [open issues](https://github.com/sshin/ExaModels.jl/issues) or [pull requests](https://github.com/sshin/ExaModels.jl/pulls) or start [discussions](https://github.com/sshin/ExaModels.jl/discussions). 
 
 ## What is ExaModels.jl?
-ExaModels.jl is an [algebraic modeling](https://en.wikipedia.org/wiki/Algebraic_modeling_language) and [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation) tool in [Julia Language](https://julialang.org/), specialized for [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) abstraction of [nonlinear programs](https://en.wikipedia.org/wiki/Nonlinear_programming). ExaModels.jl employs what we call [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) abstraction for [nonlinear programs](https://en.wikipedia.org/wiki/Nonlinear_programming) (NLPs), which allows for the preservation of the parallelizable structure within the model equations, facilitating efficient [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation) either on the single-thread CPUs, multi-threaded CPUs, as well as [GPU accelerators](https://en.wikipedia.org/wiki/Graphics_processing_unit). More details about SIMD abstraction can be found [here](/simd).
+ExaModels.jl is an [algebraic modeling](https://en.wikipedia.org/wiki/Algebraic_modeling_language) and [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation) tool in [Julia Language](https://julialang.org/), specialized for [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) abstraction of [nonlinear programs](https://en.wikipedia.org/wiki/Nonlinear_programming). ExaModels.jl employs what we call [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) abstraction for [nonlinear programs](https://en.wikipedia.org/wiki/Nonlinear_programming) (NLPs), which allows for the preservation of the parallelizable structure within the model equations, facilitating efficient [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation) either on the single-thread CPUs, multi-threaded CPUs, as well as [GPU accelerators](https://en.wikipedia.org/wiki/Graphics_processing_unit). More details about SIMD abstraction can be found [here](@ref simd).
 
 ## Key differences from other algebraic modeling tools
 ExaModels.jl is different from other algebraic modeling tools, such as [JuMP](https://github.com/jump-dev/JuMP.jl) or [AMPL](https://ampl.com/), in the following ways:
@@ -40,10 +40,10 @@ a 9241 bus system, derivative evaluation using ExaModels.jl on GPUs
 can be up to two orders of magnitude faster compared to JuMP or
 AMPL. Some benchmark results are available below. The following 
 problems are used for benchmarking:
-- [LuksanVlcek problem](../guide)
-- [Quadrotor control problem](../quad)
-- [Distillation column control problem](../dist)
-- [AC optimal power flow problem](../opf)
+- [LuksanVlcek problem](@ref guide)
+- [Quadrotor control problem](@ref quad)
+- [Distillation column control problem](@ref distillation)
+- [AC optimal power flow problem](@ref opf)
 
 ![benchmark](./assets/benchmark.svg)
 
@@ -54,9 +54,9 @@ ExaModels can be used with any solver that can handle `NLPModel` data type, but
 
 ## Documentation Structure
 This documentation is structured in the following way.
-- The remainder of [this page](.) highlights several key aspects of ExaModels.jl.
-- The mathematical abstraction---SIMD abstraction of nonlinear programming---of ExaModels.jl is discussed in [Mathematical Abstraction page](./simd).
-- The step-by-step tutorial of using ExaModels.jl can be found in [Tutorial page](./guide).
+- The remainder of this page highlights several key aspects of ExaModels.jl.
+- The mathematical abstraction---SIMD abstraction of nonlinear programming---of ExaModels.jl is discussed in [Mathematical Abstraction page](@ref simd).
+- The step-by-step tutorial of using ExaModels.jl can be found in [Tutorial page](@ref guide).
 - This documentation does not intend to discuss the engineering behind the implementation of ExaModels.jl. Some high-level idea is discussed in [a recent publication](https://arxiv.org/abs/2307.16830), but the full details of the engineering behind it will be discussed in the future publications.
 
 

docs/src/jump.jl

@@ -0,0 +1,29 @@
+# # JuMP Interface
+
+# We have an experimental interface to JuMP model. A JuMP model can be directly converted to a `ExaModel`. It is as simple as this:
+
+using ExaModels, JuMP
+
+N = 10
+jm = Model()
+
+@variable(jm, x[i = 1:N], start = mod(i, 2) == 1 ? -1.2 : 1.0)
+@constraint(
+    jm,
+    s[i = 1:N-2],
+    3x[i+1]^3 + 2x[i+2] - 5 + sin(x[i+1] - x[i+2])sin(x[i+1] + x[i+2]) + 4x[i+1] -
+        x[i]exp(x[i] - x[i+1]) - 3 == 0.0
+)
+@objective(jm, Min, sum(100(x[i-1]^2 - x[i])^2 + (x[i-1] - 1)^2 for i = 2:N))
+
+em = ExaModel(jm)
+
+# Here, note that only scalar objective/constraints created via `@constraint` and `@objective` API are supported. Older syntax like `@NLconstraint` and `@NLobjective` are not supported.
+# We can solve the model using any of the solvers supported by ExaModels. For example, we can use Ipopt:
+
+using NLPModelsIpopt
+
+result = ipopt(em)
+
+
+

docs/src/opf.jl

@@ -1,4 +1,4 @@
-# # Example: Optimal Power Flow
+# # [Example: Optimal Power Flow](@id opf)
 
 function parse_ac_power_data(filename)
     data = PowerModels.parse_file(filename)

docs/src/quad.jl

@@ -1,4 +1,4 @@
-# # Example: Quadrotor
+# # [Example: Quadrotor](@id quad)
 
 function quadrotor_model(N = 3; backend = nothing)
 

docs/src/simd.md

@@ -1,4 +1,4 @@
-# SIMD Abstraction
+# [SIMD Abstraction](@id simd)
 
 In this page, we explain what SIMD abstraction of nonlinear program is, and why it can be beneficial for scalable optimization of large-scale optimization problems. More discussion can be found in our [paper](https://arxiv.org/abs/2307.16830).