Free 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.

Partition Logic is a free hard disk partitioning and data management tool. It can create, delete, format, and move partitions and modify their attributes. It can copy entire hard disks from one to another.

Partition Logic is free software, based on the Visopsys operating system. It boots from a CD or floppy disk and runs as a standalone system, independent of your regular operating system.

Partition Logic is intended to become a free alternative to such commercial programs as Partition Magic, Drive Image, and Norton Ghost...

Class::AbstractLogic is a Perl module to handle Logic Abstractions.

SYNOPSIS

# the logic class definition
package My::Logic::Foo;
use Class::AbstractLogic-base;

# a logic action
action add,
needs [qw(a b)],
verify { a => sub { /^d+$/ }, b => sub { /^d+$/ } },
sub { $_{a} + $_{b} };

1;
...

# logic module manager creation
use Class::AbstractLogic;
my $calm = Class::AbstractLogic::Manager->new;

# loading a logic class
$calm->load_logic(Foo => My::Logic::Foo);

# requesting a result from a logic method
my $result = $calm->logic(Foo)->add(a => 11, b => 12);

# $result will be false if an exception was caught
if ($result) {
print result was . $result->value . "n";
}
else {
print exception raised: . $result->key . "n";
print error message: . $result->error . "n";
}

FLASH-PLAICE is a powerful in-circuit development tool that combines the features of a flash programmer, an emulator, and a high speed multi-channel logic analyzer into one device. The project runs uClinux.

The logic analyzer features up to 200MHz sampling rates and up to 32 input channels. The logic analyzer Java client features support for up to 200MHz sampling rates, user controlled filtering operations, time line in diagram, metadata (size, rate, and trigger position) stored in files, an ID command for device identification, configurable serial port transfer rate, user configurable drawing modes (logic level, hex value, and scope), and Java client access via almost any PC with a serial port.

The Java client uses the RXTX serial library with support for 34 platforms including Linux, Windows, and Solaris. Java client plugins include an SPI and I2C bus protocol analyzer, timing analysis to state analysis conversion, and post-processing functions.

Libircservice provides an event-driven API to develop IRC services working from a pseudo-server connection.
The library provides functions so that the developer does not need to care about the inter-server protocol and can keep the focus on the service programming logic.
Enhancements:
- This release adds timer stats, global messaging, and channel mode lock functions.
- The samples have been updated to compile with the latest API changes, and several bugs have been fixed.

Domino on Acid project is a weird colorful solitaire variant of dominoes that visualizes natural deduction.

Superficially, Dominoes on Acid is a solitaire variant of Dominoes with weird colorful tiles (and this view is enough to play the game).

But on a deeper level it is a GUI for natural deduction.

Every completed domino is equivalent to a proof of a tautology in classical propositional logic.

The game can be played online as an applet or offline as an application.

It is built on a simple isometric engine that can be used independent of the game.

XML::NodeFilter is a generic XML::NodeFilter Class.

SYNOPSIS

use XML::NodeFilter;

my $filter = XML::NodeFilter->new();

$your_iterator->set_filter( $filter );

"Filters are objects that know how to "filter out" nodes. If a NodeIterator or a TreeWalker is given a NodeFilter, it applies the filter before it returns the next node. If the filter says to accept the node, the traversal logic returns it; otherwise, traversal looks for the next node and pretends that the node was rejected was not there."

This definition is given by the DOM Traversal and Range Specification. It explains pretty well, what this class is for: A XML::NodeFilter will recieve a node from a traversal object, such as XML::LibXML::Iterator is one and tells if the given node should be returned to the caller or not.
Although I refere only to XML::LibXML here, XML::NodeFilter is implemented more open, so it can be used with other DOM implementations as well.

The Spec And The Implementation

The DOM Traversal and Range Specification just defines the contstants and accept_node() for a node filter. The XML::NodeFilter implementation also adds the what_to_show() function to the class definition, since I think that it is a filters job to decide which node-types should be shown and which not.

Also XML::NodeFilter adds two constants which are not part of the specification. The first one is FILTER_DECLINED. It tells the traversal logic, that it should apply another filter in order to decide if the node should be visible or not. While the spec only defines the traversal logic to have either one or no filter applied, it showed that it leads to cleaner code if more filter could be used in conjunktion. If a traversal logic finds a single filter that returns FILTER_DECLINED, it should be handled as a synonym of FILTER_ACCEPT. While FILTER_ACCEPT is finite and would cause all other not to be executed, FILTER_DECLINED gives one more flexibility.

The second extension of the specification is the SHOW_NONE symbol. It was added for operational completeness, so one can explicitly switch the node type filter off (means all node types are rejected). This will cause the two calls of what_to_show have a different result:

$filter->what_to_show( undef ); # will set SHOW_ALL
$filter->what_to_show( SHOW_NONE ); # will not set SHOW_ALL

Infact SHOW_NONE is a NULL flag, that means it can be added to any list of flags without altering it.

$filter->what_to_show( SHOW_ELEMENT | SHOW_TEXT | SHOW_NONE );

is therefore identical to

$filter->what_to_show( SHOW_ELEMENT | SHOW_TEXT );

SHOW_NONE is espacially usefull to avoid numerically or even more ugly unintialized values while building such flag lists dynamically.

Groundhog project is a simple logic game.

Groundhog is a game I wrote in order to get familiar with GTK because I wanted to write a plug-in for the Gimp. The program is written for Linux and published under the GPL. Apart from the GTK stuff the code is portable and will probably work on any UNIX platform.

The goal of the game is very simple: put the balls in the pockets of the same color by manipulating a maze of tubes.