Algebraic modeling language

Short description: Type of programming language

Algebraic modeling languages (AML) are high-level computer programming languages for describing and solving high complexity problems for large scale mathematical computation (i.e. large scale optimization type problems).[1] One particular advantage of some algebraic modeling languages like AIMMS,[1] AMPL,[2] GAMS,[1] Gekko, MathProg, Mosel,[1][3] and OPL is the similarity of their syntax to the mathematical notation of optimization problems. This allows for a very concise and readable definition of problems in the domain of optimization, which is supported by certain language elements like sets, indices, algebraic expressions, powerful sparse index and data handling variables, constraints with arbitrary names. The algebraic formulation of a model does not contain any hints how to process it.

An AML does not solve those problems directly; instead, it calls appropriate external algorithms to obtain a solution. These algorithms are called solvers and can handle certain kind of mathematical problems like:

* linear problems
* integer problems
* (mixed integer) quadratic problems
* mixed complementarity problems
* mathematical programs with equilibrium constraints
* constrained nonlinear systems
* general nonlinear problems
* non-linear programs with discontinuous derivatives
* nonlinear integer problems
* global optimization problems
* stochastic optimization problems

## Contents

* 1 Core elements
* 2 Design principles
* 2.1 Data driven model generation
* 3 History
* 4 Notable AMLs
* 4.1 Specialized AMLs
* 4.2 AML Packages in Generic Programming Languages
* 5 References

## Core elements

The core elements of an AML are:

* a modeling language interpreter (the AML itself)
* solver links
* user interfaces (UI)
* data exchange facilities

## Design principles

Most AML follow certain design principles:

* a balanced mix of declarative and procedural elements
* open architecture and interfaces to other systems
* different layers with separation of:
* model and data
* model and solution methods
* model and operating system
* model and interface

### Data driven model generation

Most modeling languages exploit the similarities between structured models and relational databases [4] by providing a database access layer, which enables the modelling system to directly access data from external data sources (e.g. these[5] table handlers for AMPL). With the refinement of analytic technologies applied to business processes, optimization models are becoming an integral part of decision support systems; optimization models can be structured and layered to represent and support complex business processes. In such applications, the multi-dimensional data structure typical of OLAP systems can be directly mapped to the optimization models and typical MDDB operations can be translated into aggregation and disaggregation operations on the underlying model [6]

## History

Algebraic modelling languages find their roots in matrix-generator and report-writer programs (MGRW), developed in the late seventies. Some of these are MAGEN, MGRW (IBM), GAMMA.3, DATAFORM and MGG/RWG. These systems simplified the communication of problem instances to the solution algorithms and the generation of a readable report of the results.

An early matrix-generator for LP was developed around 1969 at the Mathematisch Centrum (now CWI), Amsterdam.[7] Its syntax was very close to the usual mathematical notation, using subscripts en sigmas. Input for the generator consisted of separate sections for the model and the data. It found users at universities and in industry. The main industrial user was the steel maker Hoogovens (now Tata Steel) where it was used for nearly 25 years.

A big step towards the modern modelling languages is found in UIMP,[8] where the structure of the mathematical programming models taken from real life is analyzed for the first time, to highlight the natural grouping of variables and constraints arising from such models. This led to data-structure features, which supported structured modelling; in this paradigm, all the input and output tables, together with the decision variables, are defined in terms of these structures, in a way comparable to the use of subscripts and sets. This is probably the single most notable feature common to all modern AMLs and enabled, in time, a separation between the model structure and its data, and a correspondence between the entities in an MP model and data in relational databases. So, a model could be finally instantiated and solved over different datasets, just by modifying its datasets.

The correspondence between modelling entities and relational data models,[4] made then possible to seamlessly generate model instances by fetching data from corporate databases. This feature accounts now for a lot of the usability of optimization in real life applications, and is supported by most well-known modelling languages.

While algebraic modelling languages were typically isolated, specialized and commercial languages, more recently algebraic modelling languages started to appear in the form of open-source, specialized libraries within a general-purpose language, like Gekko or Pyomo for Python or JuMP for the Julia language.

## Notable AMLs

### Specialized AMLs

* AIMMS
* AMPL
* GAMS
* MathProg
* MiniZinc

### AML Packages in Generic Programming Languages

* FlopC++ for C++
* OptimJ for Java
* JuMP for Julia
* GBOML for Python
* Pyomo for Python

## References

1. ↑ 1.0 1.1 1.2 1.3 Kallrath, Joseph (2004). Modeling Languages in Mathematical Optimization. Kluwer Academic Publishing. ISBN 978-1-4020-7547-6. https://books.google.com/books?id=wJYART7VYe8C.
2. ↑ Robert Fourer; David M. Gay; Brian W. Kernighan (1990). "A Modeling Language for Mathematical Programming". Management Science 36 (5): 519–554–83. doi:10.1287/mnsc.36.5.519. http://revistas.uptc.edu.co/revistas/index.php/ingenieria/article/view/7309.
3. ↑ Gueret, Christelle; Prins, Christian; Sevaux, Marc (2002). Applications of Optimization with Xpress-MP. Dash Optimization Limited. ISBN 0-9543503-0-8. https://books.google.com/books?id=2hDrPQAACAA.
4. ↑ 4.0 4.1 Gautam Mitra; Cormac Lucas; Shirley Moody; Bjarni Kristjansson (1995). "Sets and indices in linear programming modelling and their integration with relational data models". Computational Optimization and Applications 4 (3): 262–283. http://www.optirisk-systems.com/publications.asp#whitepaper.
5. ↑ [1] Database and spreadsheet table handlers for AMPL
6. ↑ Koutsoukis, N.; Mitra; Lucas, C. (1999). "Adapting on-line analytical processing for decision modelling: the interaction of information and decision technologies". Decision Support Systems 26 (1): 1–30. doi:10.1016/S0167-9236(99)00021-4. http://optirisk-systems.com/publications.asp#modelling. Retrieved November 22, 2017.
7. ↑ Jac. M. Anthonisse, An input system for linear programming problems, Statistica Neerlandica 24 (1970), 143-153.
8. ↑ Francis D Ellison (1982). "UIMP: user interface for mathematical programming". ACM Transactions on Mathematical Software 8 (3): 229–255. doi:10.1145/356004.356005. http://www.optirisk-systems.com/papers/Ellison-Mitra-1982.pdf. Retrieved 2014-01-16.

* v
* t
* e

Programming paradigms

Imperative|

| Structured|

* Jackson structures
* Block-structured
* Modular
* Non-structured
* Procedural
* Programming in the large and in the small
* Design by contract
* Invariant-based
* Nested function

|

Object-oriented|

* Class-based, Prototype-based, Object-based
* Agent
* Immutable object
* Persistent
* Uniform function call syntax

Declarative|

| Functional|

* Recursive
* Anonymous function (Partial application)
* Higher-order
* Purely functional
* Total
* Strict
* GADTs
* Dependent types
* Functional logic
* Point-free style
* Expression-oriented
* Applicative, Concatenative
* Function-level, Value-level
* Monad

|

Dataflow|

* Flow-based
* Reactive (Functional reactive)
* Signals
* Streams
* Synchronous

Logic|

* Abductive logic
* Answer set
* Constraint (Constraint logic)
* Inductive logic
* Nondeterministic
* Ontology
* Probabilistic logic
* Query

Domain-
specific
language
(DSL)|

* Algebraic modeling
* Array
* Automata-based (Action)
* Command (Spacecraft)
* Differentiable
* End-user
* Grammar-oriented
* Interface description
* Language-oriented
* List comprehension
* Low-code
* Modeling
* Natural language
* Non-English-based
* Page description
* Pipes and filters
* Probabilistic
* Quantum
* Scientific
* Scripting
* Set-theoretic
* Simulation
* Stack-based
* System
* Tactile
* Templating
* Transformation (Graph rewriting, Production, Pattern)
* Visual

Concurrent,
parallel|

* Actor-based
* Automatic mutual exclusion
* Choreographic programming
* Concurrent logic (Concurrent constraint logic)
* Concurrent OO
* Macroprogramming
* Multitier programming
* Organic computing
* Parallel programming models
* Partitioned global address space
* Process-oriented
* Relativistic programming
* Service-oriented
* Structured concurrency

Metaprogramming|

* Attribute-oriented
* Automatic (Inductive)
* Dynamic
* Extensible
* Generic
* Homoiconicity
* Interactive
* Macro (Hygienic)
* Metalinguistic abstraction
* Multi-stage
* Program synthesis (Bayesian, by demonstration, by example, vibe coding)
* Reflective
* Self-modifying code
* Symbolic
* Template

Separation
of concerns|

* Aspects
* Components
* Data-driven
* Data-oriented
* Event-driven
* Features
* Literate
* Roles
* Subjects

Comparisons/Lists|

Comparison (multi-paradigm, object-oriented, functional), List (OO, by type)

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Algebraic modeling language. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Algebraic_modeling_language&oldid=4297303"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template