Converter

<repository>
	<id>obix-labs repository</id>
	<url>http://www.obix-labs.com/artifactory/obix-libs-releases</url>
</repository>

The ams converter dependency can be specified in your pom as follows:

<dependency>
	<groupId>com.obixlabs</groupId>
	<artifactId>ams-converter</artifactId>
</dependency>
	

Binary Downloads
Alternatively, you can download one of the following pre-built archives which also contains the direct dependencies of the library.

• Version 1.0.0-alpha
  • ZIP
  • TAR, GZ

Grammar & Stylesheets

• AMS XML Schema
• AMS->AMPL XSL Stylesheet
• AMS->GAMS XSL Stylesheet
• AMS->MPL XSL Stylesheet

There are a number of algebraic modelling languages which can be used for the representation and execution of optimization models. These languages are generally tied to specific and proprietary modelling systems, such as GAMS, AMPL, or MPL. This means that there is little portability in model representations. Put differently, a model can only be solved on the modelling system, in whose language it is represented. Aside from the issue of portability, these languages do not lend themselves easily to distributed computing, web-services or enterprise-level computing solutions in general.

AMS is a revolutionary approach to model representation, which not only enables the expression and storage of models and their related instance data in a portable XML format, but is also able to convert these models to target modelling languages, by use of simple XSL translation stylesheets, when required. Furthermore, it also provides graphical, command-line and programmatic tools to enable the reverse engineering of legacy model implementations into the AMS XML format.

In general, the encoding schemes used for representing optimization models are too closely aligned with the ultimate target or use of the models. Computational formats are not portable, and they couple model implementations to specific modelling platforms or systems, consequently reducing portability and reuse of models. This also makes it very difficult to use such representation formats in web-based distributing computing solutions/applications.

The main aim of AMS is to provide a mathematically complete abstraction of existing model representation schemes, which ensures portability of model representations across multiple platforms and which can be used in the construction of enterprise computing solutions which leverage advances in computing technology, such as web services and grid computing to name but a few. Put differently, AMS aims to simplify the integration of mathematical models into enterprise computing solutions by removing the barriers posed by different vendor formats and API.

• Generality: AMS is generic enough to encompass optimization paradigms ranging from linear programming to quadratic and mixed integer programming. It is even flexible enough to support the representation of constraint logic programming problems. This reduces the burden on application developers to cater for different representational formats when dealing with different problem classes e.g. linear, non-linear, etc.
• Mathematical completeness: AMS does not simply offer yet another XML syntax; its syntax is based graph theory and on the idea of a Structured Modelling Language (SML) as first muted by A.M. Geoffrion. This formal foundation actually ensures that its grammar is closely aligned with many of the modelling systems available in today's marketplace.
• Model and instance-data separation: It enforces a separation of models and the data required to instantiate them. Consequently, the same model can be re-used/solved repeatedly with different data sets. .
• Vendor-neutral model and instance-data representation: AMS is a vendor independent, which means that your model will be compatible with any modelling system for which a translation stylesheet exists.
• Portability: The AMS modelling syntax is based on plain-text XML, which means that it can be easily ported from one platform to the next. Also, all AMS tools and libraries are implemented in Java, which ensures portability across different operating systems.
• Compatibility with enterprise computing Standards and frameworks: Existing representation formats do not allow for easy exploitation of enterprise computing architectures and tools, such as web-services, grid computing etc. The AMS modelling format is XML based, which means that it can easily be used in web-service transport protocols, or plugged into enterprise solutions.

• Convert between formats: Easily convert from one format to the next and change execution environments as and when necessary. AMS provides tools that allow reverse engineering of existing models into AMS syntax, and stylesheets for converting AMS models to specific modelling languages. This in effect means that AMS can be used as a means of easily porting model representation from one platform to the next.
• Future-proof your model representation: Quite often a model's class will be changed due to a new user requirement; for example, the addition of a non-liner constraint to a previously linear model. Assume that you find yourself in a scenario such as this, and that your chosen model representation is tied to a system which will only support a simpler class of model. What do you do? Not only will you have to change your model's representation but also its execution environment. Whilst this may be acceptable for standalone/desktop-research purposes, it takes on a whole different dimension if there are other tools or systems relying on your model. Such a change could very quickly mushroom into an expensive project with a life of its own. This sort of problem can be avoided by adopting AMS as your primary model representation and storage format. It not only shields other applications from your target modelling system, but is also generic enough to encapsulate the various classes of optimization models.
• Disassociate model representation from processing: Free yourself and your organization from the tiresome practice of tying your model representation to a particular modelling system. The job of a modelling system is to allow execution of a model instance; it should not force the use of non-portable model representation syntax. AMS makes it possible to represent your model using a portable syntax with no dependency on any particular modelling system.
• Exploit modern computing tools and architectures: Build distributed and high-performance optimization solutions by exploiting distributed computing frameworks and standards such as grid computing, web-services etc. Also easily plug optimization models and libraries into your existing enterprise application landscape in the safe knowledge that your other applications are shielded from changes to the target model execution platform.
• Share: Store and share models in a universal format without regard to the specifics of execution environments of the various target audiences. Even more importantly, make it easier for modellers to pass their work onto computer programmers/IT departments who will often be in a better position to integrate these models into decision support systems. Whilst modellers are free to work in which ever target environment they choose, the models can be transferred to IT using AMS' simple XML-based format. Furthermore, from a programming point of view, instantiating the model can simply be viewed as providing an AMS XML in a particular format. Thus making it possible to supply instance data from a variety of sources e.g. database, Internet data feeds etc.