Free automated logic software for linux

Math::Logic is a Perl module that provides pure 2, 3 or multi-value logic.

SYNOPSIS

use Math::Logic qw( $TRUE $FALSE $UNDEF $STR_TRUE $STR_FALSE $STR_UNDEF ) ;
# 1 0 -1 TRUE FALSE UNDEF

use Math::Logic :NUM ; # $TRUE $FALSE $UNDEF -- what you normally want

use Math::Logic :ALL ; # All the constants

use Math::Logic :STR ; # $STR_TRUE $STR_FALSE $STR_UNDEF

# 2-degree logic
my $true = Math::Logic->new( -value => $TRUE, -degree => 2 ) ;
my $false = Math::Logic->new( -value => $FALSE, -degree => 2 ) ;
my $x = Math::Logic->new_from_string( TRUE,2 ) ;

print "true" if $true ;

# 3-degree logic (non-propagating)
my $true = Math::Logic->new( -value => $TRUE, -degree => 3 ) ;
my $false = Math::Logic->new( -value => $FALSE, -degree => 3 ) ;
my $undef = Math::Logic->new( -value => $UNDEF, -degree => 3 ) ;
my $x = Math::Logic->new_from_string( FALSE,3 ) ;

print "true" if ( $true | $undef ) == $TRUE ;

# 3-degree logic (propagating)
my $true = Math::Logic->new( -value => $TRUE, -degree => 3, -propagate => 1 ) ;
my $false = Math::Logic->new( -value => $FALSE, -degree => 3, -propagate => 1 ) ;
my $undef = Math::Logic->new( -value => $UNDEF, -degree => 3, -propagate => 1 ) ;
my $x = Math::Logic->new_from_string( ( UNDEF, 3, -propagate ) ) ;

print "undef" if ( $true | $undef ) == $UNDEF ;

# multi-degree logic
my $True = 100 ; # Define our own true
my $False = $FALSE ;
my $true = Math::Logic->new( -value => $True, -degree => $True ) ;
my $very = Math::Logic->new( -value => 67, -degree => $True ) ;
my $fairly = Math::Logic->new( -value => 33, -degree => $True ) ;
my $false = Math::Logic->new( -value => $False, -degree => $True ) ;
my $x = Math::Logic->new_from_string( "25,$True" ) ;

print "maybe" if ( $very | $fairly ) > 50 ;

# We can have arbitrarily complex expressions; the result is a Math::Logic
# object; all arguments must be Math::Logic objects or things which can be
# promoted into such and must all be compatible. The outcome depends on
# which kind of logic is being used.
my $xor = ( $x | $y ) & ( ! ( $x & $y ) ) ;
# This is identical to:
my $xor = $x ^ $y ;

Perls built-in logical operators, and, or, xor and not support 2-value logic. This means that they always produce a result which is either true or false. In fact perl sometimes returns 0 and sometimes returns undef for false depending on the operator and the order of the arguments. For "true" Perl generally returns the first value that evaluated to true which turns out to be extremely useful in practice. Given the choice Perls built-in logical operators are to be preferred -- but when you really want pure 2-degree logic or 3-degree logic or multi-degree logic they are available through this module.

The only 2-degree logic values are 1 (TRUE) and 0 (FALSE).

The only 3-degree logic values are 1 (TRUE), 0 (FALSE) and -1 (UNDEF). Note that UNDEF is -1 not undef!

The only multi-degree logic values are 0 (FALSE)..-degree -- the value of TRUE is equal to the degree, usually 100.

The -degree is the maximum value (except for 2 and 3-degree logic); i.e. logic of n-degree is n+1-value logic, e.g. 100-degree logic has 101 values, 0..100.

Although some useful constants may be exported, this is an object module and the results of logical comparisons are Math::Logic objects.

InterLOGIC game is based on an old Amiga logic game Balls. This is a graphically enhanced release of our project from 1999, and now, five years after initial release, it is made available to public.

The object of the game is to move differently colored balls through the maze, connecting it with the other same collored balls.

Two or more connected same-colored balls will disappear, and you should clean the whole maze and finish the level.

The balls are connected if they are in 90 degrees position to each other, in a row or a corner (cannot be connected diagonally).This release contains 30 mind-breaking levels for you to solve.

NACE is a generic query engine used to automatically create host and service definitions for hosts on the network.

It is intended to be used in a shell script at regular intervals by an experienced Nagios administrator to perform a query against the supplied host list. It then creates host and service definitions using the parameters supplied in the query.

Njudge is an automated judge for Diplomacy games, based on Ken Lowe software.
Installation:
1. Create a system user account (i.e. judge) and its home directory
(i.e. /home/judge) It is recommended to lock the password for this
account as you should never need to login as this user.
2. `cd to the directory containing the packages source code and type
`./configure to configure the package for your system. If youre
using `csh on an old version of System V, you might need to type
`sh ./configure instead to prevent `csh from trying to execute
`configure itself.
By default it will set up the judge in /home/judge as user judge with
an email address of judge@localhost and sendmail in /usr/sbin.
If you chose a different user and directory in step 1, or if judge
email should come from a different domain, you can give the configure
script flags to override the defaults. The flags are:
--with-dir=DIR
--with-user=NAME
--with-domain=DOMAIN
--with-sendmail=SENDMAIL
for example to set up the judge in /home/jaldhar/dip as user
jaldhar and email judge@braincells.com and sendmail in /usr/ucb, you
would do:
./configure --with-dir=/home/jaldhar/dip --with-user=jaldhar --with-domain=braincells.com --with-sendmail=/usr/ucb
There are many other flags you can give (type ./configure --help
for a full list) but these are the main ones youre likely to use.
Running `configure takes awhile. While running, it prints some
messages telling which features it is checking for.
3. Type `make to compile the package.
4. If this is a new install:
Type `make install to install the programs, any data files and
documentation. You will have to edit a few configuration files
before the judge will become operation.
If this is an upgrade from an older version;
Type make upgrade to install the new programs only.
*Note* compiled programs will not be stripped of debug and other extra
information. If you want to make compiled programs a little smaller,
you can type make install-strip or make upgrade-strip instead. This
may give a few harmless errors (when it tries to strip scripts) but you
can ignore them.
If you just want to rebuild the map files (because e.g. you added a new
variant,) type make remap.
5. 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 distclean.
Enhancements:
- Major bugfixes

Math::Logic::Predicate is a Perl module to manage and query a predicate assertion database.

SYNOPSIS

use Math::Logic::Predicate;

$db = new Math::Logic::Predicate;

# Enter some predicates into the database
$db->add(retract( smart(_) );

# Make a query
$query = $db->parse( human(H) & name(H, X) ? );
$iter = $db->match($query, $iter);

# Get the results
$name = $db->get($iter, X);

# Store it in a rule
$db->add( human_name(H, N) := human(H) & name(H, N). );

# Use it in a query
$iter = $db->match( human_name(lister, N) ? );

# Save it to a file
use Storable;
store($db->rules, red_dwarf);

Jameleon project is an automated testing framework that can be used by technical and non-technical users alike.
One of the main concepts behind it is to create a group of keywords or tags that represent different screens of an application. All of the logic required to automate each particular screen can be defined in Java and mapped to these keywords.
The keywords can then be organized with different data sets to form test scripts without requiring an in-depth knowledge of how the application works. The test scripts are then used to automate testing efforts and to generate manual test case documentation.
Jameleon was designed to test many kinds of applications. To make this possible, Jameleon was designed with a plug-in model. Currently, there are five plug-ins offered;
- A JUnit plug-in which can be used to test at a white box level. All JUnit function tags can be used in conjunction with other plug-ins.
- A Jiffie plug-in which drives Internet Explorer and can therefore only be run on Windows. Most testers like this plug-in the most.
- An HttpUnit plug-in which emulates a browser. Most developers like this plug-in the most.
- A 3270 (Jagacy) plug-in which is used to automate mainframe applications.
- A jWebUnit plug-in which is the most basic among the provided plug-ins and currently has no generic tags other than a session tag.
If Jameleon doesnt have some feature or plug-in, please feel free to request it as a feature via the Request a Feature link. Implementing Jameleon plug-ins is simple and can usually be done in less than a hour.
Even though it would be possible to write unit tests using Jameleon, Jameleon was designed with integration, regression, functional, and acceptance-level testing in mind. Most bugs are found and fixed by good unit tests. However, this does not eliminate the need to test the application as a whole.
Enhancements:
- This release includes four new features and fixes four bugs.
- A notable new feature is an experimental Selenium plug-in.
- One of the fixed bugs includes a fix to a performance slow-down in the Jiffie plug-in introduced back in the 3.3-M2 release.

Puzzled project is a program which helps you solve complex grid-type logic problems.
Puzzled is a program which will ultimately help you solve complex grid-type logic problems by understanding pseudo-English translations of the clues provided with the problem.
It can automatically reassess clues containing comparative information (or, more than, less than, next to), and it has the persistent software preferences characteristic.
It comes with a pseudo-English language parser which supports the following relationships: is, is not, more than, less than, next to, not next to, and, or, and shorthand equivalents.
Main features:
- Possibility to open and save problem files
- Automatic reassessment of clues containing comparative information (or, more than, less than, next to)
- Persistent software preferences
- Positionable toolbar
- Pseudo-english language parser supports the following relationships: is, is not, more than, less than, next to, not next to, and, or and their shorthand equivalent (=, !=, >,<<less