Free math objects 0.1.3 software for linux

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.

The GNU Scientific Library (GSL) is a C library that has hundreds of functions that are useful to scientists and mathematicians, such as special functions, linear algebra, statistics, etc... Wouldnt it be nice if you could access them all with Perl? Now you can with Math::GSL!

Warning: You are on the bleeding edge, this is alpha code, so if you want to test it out on your platform and report bugs or send patches, then please do! Yes, there is just about no documentation right now. Anyone care to write some?

WFMath is a math library that focus on geometric objects.

Thus, it includes several shapes (boxes, balls, lines), in addition to the basic math objects that are used to build these shapes (points, vectors, and matrices).

Most of the library classes can be divided into two sorts. The first kind are basic mathematical objects, whose members are all fundamental types.

The second kind are shapes, which implement the shape class interface described in doc/shape.h.

There are four classes of the first kind:

Vector
A basic mathematical vector

RotMatrix
An orthogonal matrix of determinant 1, useful for describing rotations.

Point
A point in space. This basic class also implements the shape interface in doc/shape.h.

Quaternion
A quaternion

The shape classes are:

AxisBox
A box oriented parallel to the coordinate axes

Ball
Ball< 2 > is a circle, Ball< 3 > is a sphere, etc.

Segment
A line segment, defined by its endpoints

RotBox
Like AxisBox, but it can be rotated to arbitrary angles

Polygon
A 2 dimensional polygon contained in a (possibly) larger dimensional space

The library also contains some probability-related functions, as well as wrappers for system time and random number 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.

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.