Research and Education Computing Software

AMath features

• Abstract Number class and its implementations
• Mathematical data types based on Number
• Computable formulas (trees)
• Processing mathematical formulas in their text representation
• General mathematical algorithms
• Computational module framework

AMathSys features

AFuzzy features

ADSM features

AMath features

Abstract Number class and its implementations

double precision (ScalarNumber, the default), single precision (FloatNumber), arbitrary precision based on BigDecimal (BigNumber), complex number (ComplexNumber), counting arithmetic operations (CountScalarNumber), etc. [mipt.math]

Mathematical data types based on Number

• Several abstractions of function (Function, DifferentiableFunction, MultiFunction, etc.) and their implementations working with all Number implementations [mipt.math.function.*]
• Abstract vector & matrix, and their array-based implementations [mipt.math.array]
• Vector functions & matrix functions [mipt.math.function.array]

Computable formulas (trees)

• Tree elements: Argument – abstract element of a formula tree; Parameter – argument storing its value, FunctionDependent, OperatorDependent, OperationDependent – arguments computing their values using “children” arguments; DefaultDependence – wrapper of a formula tree which can manage variable arguments [mipt.math.arg, mipt.math.arg.func]
• Symbolic differentiation of formula trees [mipt.math.arg.func.diff];
• Simplification of formula trees [mipt.math.arg.func.formula.simplification] /*will be renamed to mipt.math.arg.func.simplify */
• Support for using formula trees as functions [mipt.math.function.arg]
• Support for using mathematical objects in applications: DependenceElements (and its implementations for all Number implementations) – set of named standard elements of formula tree used e.g. to configure formula parser; MathFactory – a façade for creating mathematical objects [mipt.math.function.set]

Processing mathematical formulas in their text representation

• Abstract parser FormulaAnalyzer supporting concepts of constant, variable, operator, function and operation – function with unfixed number of parameters [mipt.math.formula];
• Parser implementation to build mipt.math.arg.func.Dependence – mipt.math.arg.func.formula.FormulaDependenceAnalyzer /*the other part of [mipt.math.arg.func.formula] is for alternative computable formula objects library including JNI and loading of java class with formula; that library is now not a part of ANum project*/;
• Renderer of formulas in GUI [mipt.math.ui].

General mathematical algorithms

• Numerical differentiation including partial derivatives [mipt.math.function.diff];
• Interpolation and searching in lookup tables [mipt.math.array.search, mipt.math.function.intperp] /* Number-based implementation of these algorithms are absent yet */
• Simple linear algebra – calculation of determinant, inverse matrix and eigenvalues [mipt.math.array.impl, used in mipt.math.array.AbstractMatrix] /* Number-based eigenvalues are not supported yet; eigenvalues support is now based on JAMA library*/.

Computational module framework

• Interfaces for multi-layer structure of any computational module: Solver (façade), Algorithm (variable part of Solver logic), Method (a small part of Algorithm or coefficients for it – DoubleArrayMethod); interface for a Solution – a result of computation; interface for a Problem to solve [mipt.math.sys, mipt.math.sys.num]
• Common mathematical concepts for use in implementations: NormOperator implementations (4), support for iterative algorithms comparing current error estimate with some tolerance at each step [mipt.math.sys.num]

AMathSys features

AMathSys framework is a concrete definition of concepts introduced in AMath (problem, solution, solver, algorithm, method) with regard to specific mathematical problems based on equation sets (systems). Interfaces/classes for problems and solutions are in subpackages of [mipt.math.sys]; solvers and default algorithms/methods are usually in subpackages of [mipt.math.sys.num]; and deeper packages contain implementations of multitude of algorithms and methods (and sometimes contain special solutions writing output data to files instead of storing them in memory).

• Systems of linear and nonlinear algebraic equations (AE) [mipt.math.sys.ae]; several direct algorithms and a dozen of iterative algorithms for AE (many of them have method(s) or parameter(s)) [mipt.math.sys.num.ae.*]
• Overdetermined systems of linear algebraic equations (the problem is often formulated with the concept of x-y table and the curve fitting to the table points); least-squares algorithm for such systems using almost all known bases [mipt.math.sys.over]
• Systems of linear (with constant or variable coefficients) and nonlinear ordinary differential equations (ODE) [mipt.math.sys.ode] – both initial value problems (IVP) and boundary value problems (BVP); several explicit and several implicit algorithms for ODE IVP like Runge-Kutta, Adams and Rosenbrock (all of them have several methods or parameter sets like Butcher table) as well as several algorithms of step size control [mipt.math.sys.num.ode.*]. Note that algorithms for BVP are not included into the framework yet.
• The Poisson elliptic-type boundary problem for (one) partial differential equation (PDE) in two-dimensional domain of arbitrary shape; and algorithms reducing this problem to solving a large system of linear algebraic equations [mipt.math.sys.num.pde.*]. Note that arbitrary shape of the boundary is not yet supported by algorithms (so rectangle domains are used).

AFuzzy features

• mipt.math.fuzzy.FuzzyNumber – the extension of mipt.math.Number class having some uncertainty and ability to calculate preference ratio over another FuzzyNumber (as extension of standard number comparison that produce discrete values {-1, 0, 1} only).
• Various implementations of FuzzyNumber [mipt.math.fuzzy]: interval number, LR and triangle numbers, GaussianNumber (characterized by standard deviation of normal probability density), DiscreteNumber (that can approximately describe any fuzzy number with concepts of alpha-cuts). Note that all these implementations have appropriate arithmetics but preference ratio calculation is implemented only in TriangleNumber yet.
• The method of fuzzy linearization and the appropriate Number classes for it [mipt.math.fuzzy.lincomb]. For simple calculations (explicit non-iterative formulas) this method gives better accuracy (avoids incorrect uncertainty growth) in comparison with direct usage of the interval, LR or Gaussian arithmetics. But the main advantage of this method is the ability to perform any iterative computations with fuzzy numbers just in the same way (with the same algorithm implementations) as with ordinary numbers (ScalarNumber, etc.)
• Some extensions of AMathSys framework to process fuzzy numbers during equation solving [mipt.math.sys.num.fuzzy]: text representation of fuzzy numbers (used during writing problem solutions to files), multiple solving of similar math problems and merging results to one fuzzy solution (it is the standard approach to account for uncertainty during equation solving – much slower nut a bit more accurate alternative for the method of fuzzy linearization).

ADSM features

ADSM framework (Abstract Decision Support Methods) defines interfaces [mipt.math.sys.alt.solve.*] and various implementations [mipt.math.sys.alt.impl.*] for algorithms of multi-criteria ranking and grading (grouping) of alternatives, as well as interfaces/classes for the appropriate problems and solutions [mipt.math.sys.alt], problems loaders from files [mipt.math.sys.alt.io.*] and command line programs solving specific problems with specific algorithms [mipt.math.sys.alt.test.*]. ADSM has the following capabilities:

• The same classes (e.g. algorithms) can be used for solving problems of various types (e.g. choice, grading and ranking problems) and for the problems in various formalizations (e.g. with continuous enumeration of alternatives and with alternative identifiers like names). As a result, the framework can be used both in command line programs and in complicated applications with UI and databases.
• Code reuse between different-type algorithms, e.g. algorithms working with alternative assessments and with alternative preferences.
• Easy combination of several algorithms into a hybrid algorithm (due to observance of solver/algorithm/method concepts introduced in AMath)
• All inputs can be uncertain (fuzzy), and that will result in computing uncertain ratings of alternatives (there exist very few algorithms supporting this feature in science!). As a result, some ADSM packages ([*.fuzzy]) depends on AFuzzy framework. Note that fuzzy grades calculation is not implemented yet (ready-to-use scientific methods haven’t been found yet) so the fuzzy ratings obtained in grading problems can be interpreted only in terms of degree of membership to grades with “crisp” boundaries.

It should be mentioned that the most general interfaces/classes for problems and solutions (in [mipt.math.sys.alt]) are suitable for classification problems (classification differs from grading only by the fact that alternative classes are unordered). But algorithms for classification problems are not implemented yet.