Free math objects software for linux

HTML Objects is a Perl module library for turning HTML tags into Perl objects. HTML Objects allows Web pages to be manipulated as a data structure rather than text.

Once manipulation is done, the entire page is generated via depth-first recursion.

Python Web Objects is a dynamic page generation system that allows the developer to embed Python code inside HTML. It is similar in function to what JSP is to Java. ts a module that runs under mod_python and the Apache webserver. It is designed to offer a good balance between a providing a clean way to integrate design content from code, while doing so as fast as possible.

Download the latest version, then read the documentation. If youre into antiques, you can always browse the archives, but theres no reason to use an old version.

To install PWO, first decompress the tarball you downloaded.
$ gunzip pwo-0.XX.tar.gz
$ tar xvf pwo-0.XX.tar

Then, copy the pwo.py module into some location in your PYTHONPATH. The proper location is usually /usr/local/lib/python2.x/site-packages/
$ cp pwo-0.XX/pwo.py /usr/local/lib/python2.2/site-packages/

PWO should now be ready to use.

To configure a directory to make PWO pages, you first need to make sure that the directory is visible on the web. Ask your friendly Apache sysadmin if you dont know what this means. In this document, the path youll be keeping your .pwo files in is called /path/to/pwodir/, and its corresponding URL is http://yourserver/url/to/pwodir/.
Let Apache and mod_python know that the pwo.py will be handling requests to .pwo files in that directory. Do this by adding a few lines to our entry in your httpd.conf file.


AddHandler python-program .pwo
PythonHandler pwo
PythonDebug On



The PythonDebug directive is optional, but you will most likely want it enabled while you are developing. It will make exceptions print tracebacks to the browser in plain-text format. For security reasons, you should comment it out on production systems.
Now a file /path/to/pwodir/some_file.pwo will generate its page at http://yourserver/url/to/pwodir/some_file.pwo. Try copying a simple one of the included samples, like hello.pwo, to this directory to test your installation.
If youve never used PWO before, learn the syntax, and/or check out some sample pages.

Basset::Object is a Perl module used to create objects.

This is my ultimate object creation toolset to date. It has roots in Mail::Bulkmail, Text::Flowchart, and the unreleased abstract object constructors that Ive tooled around with in the past.

If you want an object to be compatible with anything else Ive written, then subclass it off of here.

Of course, you dont have to use this to create subclasses, but youll run the risk of making something with an inconsistent interface vs. the rest of the system. Thatll confuse people and make them unhappy. So I recommend subclassing off of here to be consistent. Of course, you may not like these objects, but they do work well and are consistent. Consistency is very important in interface design, IMHO.

Math::Vec is a Object-Oriented Vector Math Methods in Perl.

SYNOPSIS

use Math::Vec;
$v = Math::Vec->new(0,1,2);

or

use Math::Vec qw(NewVec);
$v = NewVec(0,1,2);
@res = $v->Cross([1,2.5,0]);
$p = NewVec(@res);
$q = $p->Dot([0,1,0]);

or

use Math::Vec qw(:terse);
$v = V(0,1,2);
$q = ($v x [1,2.5,0]) * [0,1,0];

NOTICE

This module is still somewhat incomplete. If a function does nothing, there is likely a really good reason. Please have a look at the code if you are trying to use this in a production environment.

mockpp is a platform independent generic unit testing framework for C++. Mock Objects for C++ goal is to facilitate developing unit tests in the spirit of Mock Objects for Java, EasyMock and jMock.
Mock objects allow you to set up predictible behaviour to help you test your production code by emulating some functionality your code depends on. This might for example be a huge database which is too difficult and time consuming to maintain just for testing purposes.
Originally I started with a port of MockObjects to C++ and wanted to keep the same interfaces. But in the meanwhile I found out more about Java and its differencens to C++ (its funny reflection api for example ) and so I had to change a bunch of details.
Additionally I included the working method of EasyMock. From my limited understanding of Java there seems to be something similar in MockObjects but I guess EasyMock is easier to use and certainly was easier to port to C++.
Enhancements:
- This release fixes a compilation issue on Mac OS platforms and a parsing problem with mockpp2xml.

Math::BaseCalc is a Perl module that can convert numbers between various bases.

SYNOPSIS

use Math::BaseCalc;

my $calc = new Math::BaseCalc(digits => [0,1]); #Binary
my $bin_string = $calc->to_base(465); # Convert 465 to binary

$calc->digits(oct); # Octal
my $number = $calc->from_base(1574); # Convert octal 1574 to decimal

This module facilitates the conversion of numbers between various number bases. You may define your own digit sets, or use any of several predefined digit sets.

The to_base() and from_base() methods convert between Perl numbers and strings which represent these numbers in other bases. For instance, if youre using the binary digit set [0,1], $calc->to_base(5) will return the string "101". $calc->from_base("101") will return the number 5.
To convert between, say, base 7 and base 36, use the 2-step process of first converting to a Perl number, then to the desired base for the result:

$calc7 = new Math::BaseCalc(digits=>[0..6]);
$calc36 = new Math::BaseCalc(digits=>[0..9,a..z];

$in_base_36 = $calc36->to_base( $calc7->from_base(3506) );

If you just need to handle regular octal & hexdecimal strings, you probably dont need this module. See the sprintf(), oct(), and hex() Perl functions.

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.