Free predictive modeling software for linux

QML (Quantity Modeling Language) is a "thing"-based language for scientific and mathematical data modeling.
Each "thing" is a quantity which may be associated with either a structure or physical phenomena.
Quantities, in turn, may hold other Quantities or values (numbers or strings). Higher-level data models, which associate or define meanings to various quantities (such as velocity or position), can be built from QML quantities.
The higher-level data model (XML) schema that inherits from QML may be understood, and its instance documents may be parsed into QML documents and objects by the QMLReader.
Enhancements:
- This release adds partial Xerces2 DOM support, and works with Java 1.4 and Java 1.5 (no JAXP DocumentBuilder/Factory support currently).
- The test procedure is a little less chatty.
- Support has been added for testing either/both Crimson/Xerces DOM support.
- (Note: Crimson support only works with Java 1.4, as Java 1.5 interfaces have DOM lvl 2 and 3, which crimson doesnt support).
- This release adds compilerargs, and better build support for different configurations to build.xml.

Config::Model::WarpedThing is a base class for warped classes.

SYNOPSIS

use base qw/Config::Model::WarpedThing/ ;

This class must be inherited by all classes that can be warped by Config::Model::Value. This class provides a set of methods that are expected by a warp master from a warped class.

Currently this class is inherited by Config::Model::Value, Config::Model::AnyId and Config::Model::WarpedNode.

WarpThing does not provide a constructor.

KPovModeler is a modeling and composition program for creating POV-Ray scenes in KDE.
For most of the modelers, POV-Ray is nothing but a rendering engine and they bring a lot of limitations to the innate possibilities of POV-Ray scripted language. This is not the case for KPovModeler which allows you to use all the features of POV-Ray through the translation of POV-Ray language into a graphical tree.
Almost all options of POV-Rays script language can be used within KPovModeler. "Almost" because variables, loop instructions, macros and some operators cant directly be, unfortunately.
On the other hand, KPovModeler allows you to include a part of a script with the "Raw POV-Ray" tool; such a raw code will only be taken into account by POV-Ray during the rendering stage.
Main features:
- Management of the scene through a graphical tree.
- Object modification with control points in a graphical view or direct manipulation of object attributes in a dialog
- Nonblocking scene rendering with OpenGL as wire frame views
- Freely configurable view layout with dock widgets
- Copy/paste and drag/drop of (a subset of) povray(!) code into and out of the object tree
- Undo and redo
- Scene rendering and texture preview with povray inside the program
- Support for almost all povray objects
- Support for all textures
- Prototypes (declarations) and references
- All projection modes of the camera
For modeling an object, it is not required to know POV-Rays script language. On the other hand, for creating textures refering to POV-Rays documentation will be difficult to avoid.
But to ease the work, it is possible to simply cut-and-paste a script from POV-Ray into KPovModeler. KPovModeler will then, if the script only makes use of known primitives, convert the pasted text and include it into the current scene.
In other words, if you dont know how to create an object or an effect with KPovModeler, you could always copy its example from POV-Rays documentation and experiment with it within KPovModeler.

Config::Model provides a framework to help in validating the semantic content of configuration data. The project can also be used to provide a semantic check of options of a complex program like mplayer or transcode.
For most complex software, configuration upgrade is a difficult task for most people. By using Config::Model, a software can provide a smooth upgrade path for their users.
How does this work ?
Using this project, a typical configuration validation tool will be made of 3 parts :
The user interface
The validation engine which is in charge of validating all the configuration information provided by the user.
The storage facility that store the configuration information
Dont we already have some configuration validation tools ?
Youre probably thinking of tools like webmin. Yes, these tools exist and work fine, but they have their set of drawbacks.
Usually, the validation of configuration data is done with a script which performs semantic validation and often ends up being quite complex (e.g. 2500 lines for Debians xserver-xorg.config script which handles xorg.conf file).
In most cases, the configuration model is expressed in instructions (whatever programming language is used) and interspersed with a lot of processing to handle the actual configuration data.
Whats the advantage of this project ?
The Config::Model projects provide a way to get a validation engine where the configuration model is completely separated from the actual processing instruction.
The configuration model is expressed in a declarative form (i.e. a Perl data structure) which is always easier to maintain than a lot of code.
The declaration specifies:
the structure of the configuration data (which can be queried by generic user interfaces)
the properties of each element (boundaries, check, integer or string, enum like type ...)
the default values of parameters (if any)
mandatory parameters
the targeted audience (intermediate, advance, master)
on-line help (for ach parameter or value of parameter)
the level of expertise of each parameter (to hide expert parameters from newbie eyes)
So, in the end:
maintenance and evolution of the configuration content is easier
user will see a *common* interface for *all* programs using this project.
user will not see advanced parameters
upgrade of configuration data is easier and sanity check is performed
audit of configuration is possible to check what was modified by the user compated to default values
What about the user interface ?
Config::Model will also come with a Curses::UI interface that queries the users model and generate the relevant user screens.
What about data storage ?
Since the syntax of configuration files vary wildly form one program to another, most people who want to use this framework will have to provide a dedicated parser/writer.
Nevertheless, this project can also provide a writer/parser for most common format: like ini style file, or provide an interface to the Elektra or debconf projects. This point is open for discussion.
It is entirely possible for a single configuration model to use several parsers and writers so one model will ensure the consistency of several configuration files together.
Enhancements:
- The Xorg model was updated to Config::model version 0.609.
- Some bugs were fixed.

Yukatan data model project is the schema definition of the Yukatan webmail database.
The PostgreSQL database structures defined in this file can be used as a backend store of an email message handling application. The database should be created with the "UNICODE" encoding to properly support messages in different languages.
New data types
The special data types commonly used in the Yukatan data model have been made explicit by the introduction of seven new domains. The domains and the related COMMENT statements make field semantics more clear than before.
See the SQL schema file for more detailed documentation on these domains.
Explicitly named constraints
All the table constraints in the database are now explicitly named and documented. This change makes the database implementation more orthogonal and cleans up the documentation.
Renamed fields and tables
All the *address field names have been truncated to *addr, to make it visually clearer that they are always paired with the corresponding *name fields. The change also makes parts of the documentation less repetitive.
The referencesfield table has been renamed to referencefield to avoid the plural form in the table name. Also all the contained references* field names have been renamed to reference*.
Semantic changes
Quite a few changes have been made to the semantics of various fields. The unnecessarily tight constraints on sequence numbers have been replaced with clearer documentation, the format and encoding of most fields has been explicitly documented, and the previously allowed dual use of the enttext and enddata fields has been prohibited.
Dropped envelope data
The envelope data added in version 0.5 of the data model has for now been removed. The reason for the removal is that the envelope data is not an integral part of an email message, and I wanted to make the version 1.0 as clear as possible. The database now stores "email messages" - nothing less, nothing more. Envelope data can and probably will be reintroduced in an incremental version 1.x along with other extensions.
Enhancements:
- cleans up and documents the data model that has developed since version 0.1
- removal of the envelope data added in version 0.5
- enaming and redefinition of some of the fields and tables
- database structure has also been extensively documented

JSBSim Flight Dynamics Model is an open source flight dynamics model (FDM) that compiles and runs under many operating systems, including Linux, Apple Macintosh, Microsoft Windows, Linux, IRIX, Cygwin (Unix on Windows), etc.
The FDM is essentially the physics/math model that defines the movement of an aircraft under the forces and moments applied to it using the various control mechanisms and from the forces of nature.
JSBSim has no native graphics. It can be run by itself as a standalone program, taking input from a script file and various aircraft configuration files; or, it can be run as an integrated part of a larger flight simulator implementation that includes a visual system.
The most notable example of the use of JSBSim is currently seen in the open source FlightGear simulator. JSBSim models the aerodynamic forces and moments by the classic coefficient buildup method.
JSBSim has seen the growth of a fairly large user base, with some of the more notable projects (of which I am aware) described on the Users page.
Main features:
- Fully configurable flight control system, aerodynamics, propulsion, landing gear arrangement, etc. through XML-based text file format.
- Rotational earth effects on the equations of motion (coriolis and centrifugal acceleration modeled).
- Configurable data output formats to screen, file, socket, or any combination of those.
Enhancements:
- This release includes new options for the standalone JSBSim executable, including improved real-time capability.
- This release also includes experimental (but tested) logic to reduce ground reactions jitter while on the ground.

Installation: The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
2. Running `configure might take a while. While running, it prints some messages telling which features it is checking for.
3. Type `make to compile the package.
4. Optionally, type `make check to run any self-tests that come with the package.
5. Type `make install to install the programs and any data files and
6. documentation.
7. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make disclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

Vertex 3D Model Assembler project is a polygon-based live-end modeller.

The Vertex 3D Model Assembler is a 3D modeller geared towards making high performance models for games and other live-end requirements.

It uses the V3D format to maximize efficiency with OpenGL rendering, and can view/edit any V3D hybrid data.