Free logical software for linux

XLogical project is a parallel thinking puzzle game with ray-traced graphics, music, and sound.

XLogical is a puzzle game based on an Amiga game developed by Rainbow Arts called Logical. It features ray-traced graphics, music, and sound effects. The game is addictive, requiring parallel thinking and quick reflexes.

We enjoyed playing it so much back in its day that we decided it would be a fun project to recreate it for Linux - our new OS of choice.

We originally started with GTK for the rendering system, but eventually decided that SDL was more apropriate for what we were trying to accomplish ( after attempting to make GTK work like SDL for awhile ).

So, while not without its grief, this project was a good one. We hope you enjoy the game!

Linux Logical Volume Management HOWTO is describing Linux Logical Volume Management.
Logical Volume Management is the art of combining disks to create larger and more flexible filesystems.
You can concatenate partitions to create huge volumes.
Its also possible to create volume snapshots which enable more or less hot backups.
But you can also transparently move data from one disk to another.
This HOWTO helps you in a very hands-on way to use these amazing tools.
Enhancements:
- Released version 0.0.2 - these version numbers a rather bogus, but every once in a while we feel that we have progressed significantly, and bump the version number a bit. The version on this page is up to date within 15 minutes of our latest changes.

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.

libogg is the bitstream and framing library for the Ogg project. libogg provides functions which are necessary to codec libraries like libvorbis.

Ogg codecs use octet vectors of raw, compressed data (packets). These compressed packets do not have any high-level structure or boundary information; strung together, they appear to be streams of random bytes with no landmarks.

Raw packets may be used directly by transport mechanisms that provide their own framing and packet-separation mechanisms (such as UDP datagrams).

For stream based storage (such as files) and transport (such as TCP streams or pipes), Vorbis and other future Ogg codecs use the Ogg bitstream format to provide framing/sync, sync recapture after error, landmarks during seeking, and enough information to properly separate data back into packets at the original packet boundaries without relying on decoding to find packet boundaries.

Raw packets are grouped and encoded into contiguous pages of structured bitstream data called logical bitstreams. A logical bitstream consists of pages, in order, belonging to a single codec instance.

Each page is a self contained entity (although it is possible that a packet may be split and encoded across one or more pages); that is, the page decode mechanism is designed to recognize, verify and handle single pages at a time from the overall bitstream.

Multiple logical bitstreams can be combined (with restrictions) into a single physical bitstream. A physical bitstream consists of multiple logical bitstreams multiplexed at the page level and may include a meta-header at the beginning of the multiplexed logical stream that serves as identification magic.

Whole pages are taken in order from multiple logical bitstreams and combined into a single physical stream of pages. The decoder reconstructs the original logical bitstreams from the physical bitstream by taking the pages in order from the physical bitstream and redirecting them into the appropriate logical decoding entity. The simplest physical bitstream is a single, unmultiplexed logical bitstream with no meta-header; this is referred to as a degenerate stream.

Ogg Logical Bitstream Framing discusses the page format of an Ogg bitstream, the packet coding process and logical bitstreams in detail. The remainder of this document specifies requirements for constructing finished, physical Ogg bitstreams.

Icecast is a streaming media server which currently supports Ogg Vorbis and MP3 audio streams.
Icecast can be used to create an Internet radio station or a privately running jukebox and many things in between.
It is very versatile in that new formats can be added relatively easily, and it supports open standards for communication and interaction.
Enhancements:
New features:
- new tag < logsize > in < logging > state the trigger size (in KB) for cycling the log files.
- new tag < logarchive > in < logging > enable (1) if you want to use a timestamp for an extension when cycling logs.
Fixes:
- Handling of certain shoutcast source clients is fixed, this typically affected NSV source clients
- A race in source shutdown when listeners are authenticated could lead to server crash
- An audio glitch was possible in playback of vorbis streams when a new logical stream started (eg metadata update).
- stats speedup. Processing large numbers of stats was slow. Typically only seen when using lots of streams on the same server.
- 404 responses were being sent back in some places, now 403 is sent back.
- Auth URL now handles the authentication to scripts better.
- The order in which username/password are selected is
- 1. url is http://user:pass@host:port/....
- 2. < param name="username" > and < param name="password" >
- 3. with listener_add/remove, listener supplied username/password is used.
- A streams intro file can now be changed, using HUP, on active streams.
- mount without a name crashed the server
- Various documentation updates

yagg::Tutorial is a Perl module that contains a tutorial for yagg.

SYNOPSIS

# To use the generator
./yagg -m nonterminals.yg terminals.lg
./output/progs/generate 5

This tutorial will show you how to use yagg, by way of two examples. In the first example, we create a simple logical expression generator from scratch. In the second example, we create a more sophisticated logical expression generator from existing parser/lexer input files, such as those used by YACC/Bison and LEX/FLEX. These examples, plus another more sophisticated fault tree generator are included with the distribution in the examples/ directory.

It is assumed that the reader knows a little about formal grammars. Ideally, the reader would have some experience writing grammars for input to parser generators like YACC and Bison.

OpenDocMan is a Web-based document management system.
Written in PHP, and utilizing MySQL for the backend, this project is useful for any company looking to keep their documentation in a centralized repository
Main features:
- automated installation script
- check-in/out
- departmental access control
- file moderation
- fine grained user access control
- search function