Free programs software for linux

Solving Constraint Integer Programs is a framework for constraint integer programming. For solving Integer Programs and Constraint Programs, a very similar technique is used: the problem is successively divided into smaller subproblems (branching) that are solved recursively.
On the other hand, Integer Programming and Constraint Programming have different strengths: Integer Programming uses LP relaxations and cutting planes to provide strong dual bounds, while Constraint Programming can handle arbitrary (non-linear) constraints and uses propagation to tighten the variables domains.
SCIP is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as pure MIP solver or as framework for branch-cut-and-price.
Main features:
- It is a framework for branching, cutting, pricing, and propagation.
- It is highly flexible through many possible user plugins:
- constraint handlers to implement arbitrary constraints,
- variable pricers to dynamically create problem variables,
- domain propagators to apply constraint independent propagations on the variables domains,
- cut separators to apply cutting planes on the LP relaxation,
- relaxators to provide relaxations and dual bounds in addition to the LP relaxation,
- primal heuristics to search for feasible solutions with specific support for probing and diving,
- node selectors to guide the search,
- branching rules to split the problem into subproblems,
- presolvers to simplify the solved problem,
- file readers to parse different input file formats,
- event handlers to be informed on specific events, e.g., when a node was solved, a specific variable changed its bounds, or a new primal solution was found,
- display handlers to create additional columns in the solvers output.
- dialog handlers to extend the included command shell.
- Every existing unit is implemented as a plugin, leading to an interface flexible enough to meet the needs of most additional user extensions.
- A dynamic cut pool management is included.
- The user may mix preprocessed and active problem variables in expressions: they are automatically transformed to corresponding active problem variables.
- Arbitrarily many children per node can be created, and the different children can be arbitrarily defined.
- It has an open LP solver support (currently supporting ILOG CPLEX, Dash XPress-MP, SoPlex, and CLP.
- The LP relaxation need not to be solved at every single node (it can even be turned off completely, mimicing a pure constraint solver).
- Additional relaxations (e.g., semidefinite relaxations or Lagrangian relaxations) can be included, working in parallel or interleaved.
- Conflict analysis can be applied to learn from infeasible subproblems.
- Dynamic memory management reduces the number of operation system calls with automatic memory leakage detection in debug mode.
Enhancements:
- The new heuristics "RENS", "mutation", "veclendiving", and "intshifting", were included.
- The existing ones were improved.
- Presolving and c-MIR cut generation were improved.
- A few bugs were fixed.

Program Guard allows the user of a Linux workstation to specify which application programs that are allowed TCP/IP connections to the Internet (Internet addresses are defined as any IP address not in the range of 10.0.0.0/24 or 192.168.0.0/16).

The application program names can be specified by listing them in a file (Static Mode) by querying the user (Query Mode). In Query Mode, when a program that is unknown to Program Guard attempts to access an Internet IP address, Program Guard displays the Program Guard Dialog Box.

In addition to providing connection information, this dialog box gives the workstation user the option of allowing the program to access the Internet or to be blocked from accessing the Internet. This can be done either for the current instance of the program or for this and all future instances of the program (Make Persistent checkbox).

Currently, the program names that are allowed or denied Internet access apply to all users of the workstation rather than on a per user basis. For example, if Program Guard is running in Query Mode and user A invokes a program previously blocked from Internet access by user B, the program will be blocked from Internet access for User A as well.

Connections blocked by Program Guard are logged to the Program Guard log file pgrd.log. It is located in the /var/log/pgrd directory. If desired, Program Guard can be configured to log all Internet connection attempts rather than just those that have been blocked.

Program Guard was tested on Fedora Core 1 and Fedora Core 3 on single processor 32 bit X86 Intel processors. It has not been tested on other distributions or on multi-processor machines. While it works on Fedora Core 1, it will not build on a standard Linux 2.4.x kernel due to task_struct definitions that were not made until Linux 2.6. If there is enough interest, a version that runs under a standard Linux 2.4 kernel may be made available.

To run in Query Mode, Gnome 2.x and Glade 2.x are required. There are no prerequisites for Static Mode.

Installation:

Program Guard consists of three components: a kernel module; a daemon; and a Gnome GUI user interface component. All files needed to build the components are in the pgrd.tgz file. An installation shell script install-pgrd is provided for Fedora distributions.

It will build/install (or remove) the kernel module and daemon as well as configure them to be started automatically when the system is booted. To invoke it, type install-pgrd < install | remove >. This script may or may not be useable as is for other Linux distributions.

If you modify the install script, please note that the module, daemon and various support files must be installed in the /opt/pgrd directory for Program Guard to work properly (this is already handled when using the install script as provided). To run in Query Mode, each user must be configured by invoking the install-pgrd_user < username > script. And by going to the Preferences->More Preferences->Sessions selection in the Fedora Main Menu and adding pgrdgui to the Startup Programs tab.

Program Guard will be started the next time the machine is rebooted. If you do not wish to reboot, you may start Program Guard manually as described below in Manual Starting And Stopping. Note: If starting manually and using Query Mode, once the daemon and kernel module are started, make sure that you log out and log back in.

AIMLBot (Program#) is a small, fast, standards-compliant yet easily customizable .NET dll implementation of an AIML (Artificial Intelligence Markup Language) based chatter bot.
AIMLBot has been tested on both Microsofts runtime environment and Mono. Put simply, it will allow you to chat (by entering text) with your computer using natural language.
This is the second version of the library and it has been re-written from scratch.
Main features:
- Better cross-platform compatibility. Support for .NET 1.1, 2.0 and XNA as well as the open source Mono project (tested under version 1.1). Testing on Windows Vista with version 3.0 of the .NET platform is pending.
- A completely new modular architecture to make it easier for developers to extend and add functionality.
- A simpler and more logical API.
- Standards compliant AIML support with the option for custom tags.
- Very small size (currently only 52k).
- Very fast (over 30,000 categories processed in under a second).
- Inclusion of a comprehensive test suite including over 200 unit tests (based upon nUnit).
- A means of saving the bots "brain" as a binary file (Graphmaster.dat).
- Some simple code snippets and examples for developers to get started (simple windows and console based applications as well as a sample custom tags library).
- Appropriately commented code.
- Comprehensive documentation.
Enhancements:
- This version fixes a rather serious bug that crept into the last version where regex-based replacements caused the bot to either time out or produce incorrect paths for the graphmaster algorithm.
- In addition, generics are now used throughout, which will improve the performance of the bot.