Free multiply software for linux

Multi Network Firewall is the up-to-date Mandriva Linux security solution dedicated to the business world. Maximum innovation, performance and scalability is only a click away thanks to an easy-to-use web interface.
Combining firewall, Intrusion Detection System and VPN functionality, MNF 2 is the ultimate full-featured security solution meeting all your demands. Furthermore, to make your network even more secure, benefit from a year of free updates through Mandriva Online Pro!
Main features:
- a firewall, to protect your computer network from unauthorized access (filtering).
- Intrusion Detection System, to alert you to abnormal network activity.
- Virtual Private Network, to enable a secure private tunnel over public networks.
- Proxy server, to intercept all web traffic entering the network.
- DHCP server, to enable the automatic configuration of new machines connected to the LAN.
- Caching DNS, to provide a local DNS service for computers connected to the LAN.
New Featurs:
As well as the existing IPSec, MNF2 provides 2 other types of VPN:
PPTP: a desktop under Windows(R) can be automatically connected without installing any special software
OpenVPN: a lighter open source VPN; Compattible with Linux, Mac OS and Windows
Bonding: Channel combines several network interfaces into a single connection. Effectively, it means that data transfer speeds can be multiplied.
Bridging: this new function enables the administrator to build bridges between network interfaces.
Traffic shaping: You can regulate the flow of traffic on your network just by clicking on a wizard.
Network mapping: Makes it possible to connect networks which use the same private network addresses
Peer-to-Peer Filtering: MNF2 automatically blocks network traffic from "Fast Track" peer-to-peer clients.
Better software support
2.6 Linux Kernel
Better hardware support
Improved support for multiple network cards (up to 10)
Wi-Fi Support
Better ADSL support
Services included in the product
Mandriva Online Pro: benefit from updates for one year through Mandriva Online Pro
Support included/

Liboil is a library of simple functions that are optimized for various CPUs. These functions are generally loops implementing simple algorithms, such as converting an array of N integers to floating-point numbers or multiplying and summing an array of N numbers.
Such functions are candidates for significant optimization using various techniques, especially by using extended instructions provided by modern CPUs (Altivec, MMX, SSE, etc.).
Many multimedia applications and libraries already do similar things internally. The goal of this project is to consolidate some of the code used by various multimedia projects, and also make optimizations easier to use by a broader range of applications.
As of the liboil-0.3.0 release, Im actively encouraging other open-source projects to begin using liboil. Im happy to do much of work converting projects to use liboil, and especially, adding function classes and implementations to liboil that may be needed.
Liboil does not require GCC to build, but since it uses GCC-style inline assembly heavily, using GCC is strongly recommended. Versions of GCC prior to 3.2 are known to have problems compiling liboil correctly. GLib-2.0 is recommended to build a few of the examples, but is not required for anything that is installed.
Liboil may be modified and distributed in accordance with a very liberal license commonly referred to as "Two-Clause BSD". This license was chosen to make liboil useful to as many open-source projects as possible, and has the side effect of also allowing liboil to be used by proprietary applications.
Liboil has a number of function classes, which are primarily seen by a developer using the library as actual functions. One such function is:
void oil_tablelookup_u8 (uint8_t *dest, int dstr, uint8_t *src,
int sstr, uint8_t *table, int tablestride, int n);
This function performs a table lookup for each element in the src array, and puts the results in the dest array. In actuality, oil_tablelookup_u8 is a preprocessor macro that generates the correct code to call an indirect function.
Each function class has one or more function implementations, which are real functions that perform the exact same action as defined by the documentation for the function. Each class has one implementation that is the reference implementation. This reference implmentation is used to test the accuracy of other implementations.
Presumably, the non-reference implementations can perform the action faster than the reference implementation. Thus, the liboil initialization code (at runtime) checks each implementation in a class to determine the fastest implementation. Once this is done, the classs indirect function pointer points to the optimal implementation. After this, any calls to the function class (such as oil_tablelookup_u8() described above) will automatically be routed to the fastest implementation.
Implementations can be disabled either at compile time (e.g., assembly code for the wrong architecture) or at run time (e.g., implementation uses unsupported opcodes). This is done automatically. In addition, implementations may be disabled because they do not produce the same results as the reference implementation.
All of the function classes will be API and ABI stable through the lifetime of the 0.3 series. In addition, the 0.4 series will include a compatibility library that will provide the 0.3 ABI. This allows multiple liboil-using libraries to be linked into the same application without regard to using the same liboil ABI. New ABI versions (0.4, 0.5, etc.) are expected no less than 6 months apart. It is planned that all future versions of liboil will support at least two liboil ABI versions.
Enhancements:
- Support for the jpeg decoder was improved.
- C++ support was improved.
- Various speedups and smaller improvements were done.

RPN is a Perl extension for Reverse Polish Math Expression Evaluation.

SYNOPSIS

use Math::RPN;
$value=rpn(expr...);
@array=rpn(expr...);

expr... is one or more scalars or lists of scalars which contain
RPN expressions. An RPN expression is a series of numbers and/or
operators separated by commas. (commas are only required within
scalars).

The rpn function will take a scalar or list of sclars which contain an RPN expression as a set of comma delimited values and operators, and return the result or stack, depending on context. If the function is called in an array context, it will return the entire remaining stack. If it is called in a scalar context, it will return the top item of the stack. In a scalar context, if more than one value remains on the stack, a warning will be sent to STDERR.

In the event of an error, an error message will be sent to STDERR, and rpn will return undef.

The expression can contain any combination of values and operators. Any token which is not an operator is assumed to be a value to be pushed onto the stack.

An explanation of Reverse Polish Notation is beyond the scope of this document, but it I will describe it briefly as a stack-based way of writing mathematical expressions. This has the advantage of eliminating the need for parenthesis and simplifying parsing for computers vs. normal algebraic notation at a slight cost in the ability of humans to easily comprehend the expressions.
This evaluator works by cycling through the expression from left to right. As each token is encountered, it is checked against the list of operators. If it matches, then a check is performed for stack underflow.

If the stack has not underflowed, the operation is performed by removing the required number of operands from the top of the stack. The result is then pushed on to the stack. Operations for which order is significant (-,/,%,etc.) are processed such that the top item on the stack is treated as the right operand, and the next item down is treated as the left operand. Thus, "5,3,-" would yield 2, not -2. If the token does not match any of the known operators, the token is blindly pushed onto the stack. As a result, one can produce unexpected results. For example, the expression "5,3,grandma,+,*" would produce 15 because 5*(3+0) is how it would end up evaluated. That is, 5 would be pushed onto the stack, then 3, then "grandma". Next, + is evaluated, so 3+"grandma" is evaluated. PERL evaluates "grandma" to be numerically 0, so 3 is pushed back onto the stack. Next, the * multiplies the top two items of the stack [5][3], producing 15, which is pushed back onto the stack.

Gimp::PDL is a Perl module to overwrite Tile/Region functions to work with piddles. This module is obsolete, please remove any references to it.

SYNOPSIS
use Gimp;
use Gimp::PDL;
use PDL;

This module overwrites some methods of Gimp::Tile and Gimp::PixelRgn. The new functions return and accept piddles. The last argument (height) of gimp_pixel_rgn_set_rect is calculated from the piddle. There is no other way to access the raw pixeldata in Gimp.

Some exmaples:

$region = $drawable->get->pixel_rgn (0,0, 100,100, 1,0);
$pixel = $region->get_pixel (5,7); # fetches the pixel from (5|7)
print $pixel; # outputs something like
# [255, 127, 0], i.e. in
# RGB format ;)
$region->set_pixel ($pixel * 0.5, 5, 7);# darken the pixel
$rect = $region->get_rect (3,3,70,20); # get a horizontal stripe
$rect = $rect->hclip(255/5)*5; # clip and multiply by 5
$region->set_rect($rect); # and draw it!
undef $region; # and update it!

Math::Cephes is a Perl interface to the cephes math library.

SYNOPSIS

use Math::Cephes qw(:all);

This module provides an interface to over 150 functions of the
cephes math library of Stephen Moshier. No functions are exported
by default, but rather must be imported explicitly, as in

use Math::Cephes qw(sin cos);

There are a number of export tags defined which allow
importing groups of functions:
use Math::Cephes qw(:constants);
imports the variables

$PI : 3.14159265358979323846 # pi
$PIO2 : 1.57079632679489661923 # pi/2
$PIO4 : 0.785398163397448309616 # pi/4
$SQRT2 : 1.41421356237309504880 # sqrt(2)
$SQRTH : 0.707106781186547524401 # sqrt(2)/2
$LOG2E : 1.4426950408889634073599 # 1/log(2)
$SQ2OPI : 0.79788456080286535587989 # sqrt( 2/pi )
$LOGE2 : 0.693147180559945309417 # log(2)
$LOGSQ2 : 0.346573590279972654709 # log(2)/2
$THPIO4 : 2.35619449019234492885 # 3*pi/4
$TWOOPI : 0.636619772367581343075535 # 2/pi

As well, there are 4 machine-specific numbers available:

$MACHEP : machine roundoff error
$MAXLOG : maximum log on the machine
$MINLOG : minimum log on the machine
$MAXNUM : largest number represented
use Math::Cephes qw(:trigs);
imports

acos: Inverse circular cosine
asin: Inverse circular sine
atan: Inverse circular tangent (arctangent)
atan2: Quadrant correct inverse circular tangent
cos: Circular cosine
cosdg: Circular cosine of angle in degrees
cot: Circular cotangent
cotdg: Circular cotangent of argument in degrees
hypot: hypotenuse associated with the sides of a right triangle
radian: Degrees, minutes, seconds to radians
sin: Circular sine
sindg: Circular sine of angle in degrees
tan: Circular tangent
tandg: Circular tangent of argument in degrees
cosm1: Relative error approximations for function arguments near unity
use Math::Cephes qw(:hypers);
imports

acosh: Inverse hyperbolic cosine
asinh: Inverse hyperbolic sine
atanh: Inverse hyperbolic tangent
cosh: Hyperbolic cosine
sinh: Hyperbolic sine
tanh: Hyperbolic tangent
use Math::Cephes qw(:explog);
imports

exp: Exponential function
expxx: exp(x*x)
exp10: Base 10 exponential function (Common antilogarithm)
exp2: Base 2 exponential function
log: Natural logarithm
log10: Common logarithm
log2: Base 2 logarithm
log1p,expm1: Relative error approximations for function arguments near unity.
use Math::Cephes qw(:cmplx);
imports

new_cmplx: create a new complex number object
cabs: Complex absolute value
cacos: Complex circular arc cosine
cacosh: Complex inverse hyperbolic cosine
casin: Complex circular arc sine
casinh: Complex inverse hyperbolic sine
catan: Complex circular arc tangent
catanh: Complex inverse hyperbolic tangent
ccos: Complex circular cosine
ccosh: Complex hyperbolic cosine
ccot: Complex circular cotangent
cexp: Complex exponential function
clog: Complex natural logarithm
cadd: add two complex numbers
csub: subtract two complex numbers
cmul: multiply two complex numbers
cdiv: divide two complex numbers
cmov: copy one complex number to another
cneg: negate a complex number
cpow: Complex power function
csin: Complex circular sine
csinh: Complex hyperbolic sine
csqrt: Complex square root
ctan: Complex circular tangent
ctanh: Complex hyperbolic tangent
use Math::Cephes qw(:utils);
imports

cbrt: Cube root
ceil: ceil
drand: Pseudorandom number generator
fabs: Absolute value
fac: Factorial function
floor: floor
frexp: frexp
ldexp: multiplies x by 2**n.
lrand: Pseudorandom number generator
lsqrt: Integer square root
pow: Power function
powi: Real raised to integer power
round: Round double to nearest or even integer valued double
sqrt: Square root
use Math::Cephes qw(:bessels);
imports

i0: Modified Bessel function of order zero
i0e: Modified Bessel function of order zero, exponentially scaled
i1: Modified Bessel function of order one
i1e: Modified Bessel function of order one, exponentially scaled
iv: Modified Bessel function of noninteger order
j0: Bessel function of order zero
j1: Bessel function of order one
jn: Bessel function of integer order
jv: Bessel function of noninteger order
k0: Modified Bessel function, third kind, order zero
k0e: Modified Bessel function, third kind, order zero, exponentially scaled
k1: Modified Bessel function, third kind, order one
k1e: Modified Bessel function, third kind, order one, exponentially scaled
kn: Modified Bessel function, third kind, integer order
y0: Bessel function of the second kind, order zero
y1: Bessel function of second kind of order one
yn: Bessel function of second kind of integer order
yv: Bessel function Yv with noninteger v
use Math::Cephes qw(:dists);
imports

bdtr: Binomial distribution
bdtrc: Complemented binomial distribution
bdtri: Inverse binomial distribution
btdtr: Beta distribution
chdtr: Chi-square distribution
chdtrc: Complemented Chi-square distribution
chdtri: Inverse of complemented Chi-square distribution
fdtr: F distribution
fdtrc: Complemented F distribution
fdtri: Inverse of complemented F distribution
gdtr: Gamma distribution function
gdtrc: Complemented gamma distribution function
nbdtr: Negative binomial distribution
nbdtrc: Complemented negative binomial distribution
nbdtri: Functional inverse of negative binomial distribution
ndtr: Normal distribution function
ndtri: Inverse of Normal distribution function
pdtr: Poisson distribution
pdtrc: Complemented poisson distribution
pdtri: Inverse Poisson distribution
stdtr: Students t distribution
stdtri: Functional inverse of Students t distribution
use Math::Cephes qw(:gammas);
imports

fac: Factorial function
gamma: Gamma function
igam: Incomplete gamma integral
igamc: Complemented incomplete gamma integral
igami: Inverse of complemented imcomplete gamma integral
psi: Psi (digamma) function
rgamma: Reciprocal gamma function
use Math::Cephes qw(:betas);
imports

beta: Beta function
incbet: Incomplete beta integral
incbi: Inverse of imcomplete beta integral
lbeta: Natural logarithm of |beta|
use Math::Cephes qw(:elliptics);
imports

ellie: Incomplete elliptic integral of the second kind
ellik: Incomplete elliptic integral of the first kind
ellpe: Complete elliptic integral of the second kind
ellpj: Jacobian Elliptic Functions
ellpk: Complete elliptic integral of the first kind
use Math::Cephes qw(:hypergeometrics);
imports

hyp2f0: Gauss hypergeometric function F
hyp2f1: Gauss hypergeometric function F
hyperg: Confluent hypergeometric function
onef2: Hypergeometric function 1F2
threef0: Hypergeometric function 3F0
use Math::Cephes qw(:misc);
imports

airy: Airy function
bernum: Bernoulli numbers
dawsn: Dawsons Integral
ei: Exponential integral
erf: Error function
erfc: Complementary error function
expn: Exponential integral En
fresnl: Fresnel integral
plancki: Integral of Plancks black body radiation formula
polylog: Polylogarithm function
shichi: Hyperbolic sine and cosine integrals
sici: Sine and cosine integrals
simpson: Simpsons rule to find an integral
spence: Dilogarithm
struve: Struve function
vecang: angle between two vectors
zeta: Riemann zeta function of two arguments
zetac: Riemann zeta function
use Math::Cephes qw(:fract);
imports

new_fract: create a new fraction object
radd: add two fractions
rmul: multiply two fractions
rsub: subtracttwo fractions
rdiv: divide two fractions
euclid: finds the greatest common divisor

SYNOPSIS

use Math::MatrixReal;
use Math::MatrixReal::Aug;

These are certain extra methods for Math::MatrixReal, in the tradition of Math::MatrixReal::Ext1;

$matrix1->augmentright($matrix2);

Creates a new matrix of the form [$matrix1 $matrix2]. $matrix1 and $matrix2 must have the same number of rows.

Example:

$A = Math::MatrixReal->new_from_cols([[1,0]]);
$B = Math::MatrixReal->new_from_cols([[1,2],[2,1]]);

$C = $A / $B
print $C;

[ 1.000000000000E+00 1.000000000000E+00 2.000000000000E+00 ]
[ 0.000000000000E+00 2.000000000000E+00 1.000000000000E+00 ]

$matrix1->augmentbelow($matrix2);

Creates a new matrix of the form [ $matrix1 ] [ $matrix2 ]. $matrix1 and $matrix2 must have the same number of columns.

Example:

$A = Math::MatrixReal->new_from_cols([[1,0],[0,1]]);
$B = Math::MatrixReal->new_from_cols([[1,2],[2,1]]);

$C = $A / $B
print $C;

[ 1.000000000000E+00 0.000000000000E+00 ]
[ 0.000000000000E+00 1.000000000000E+00 ]
[ 1.000000000000E+00 2.000000000000E+00 ]
[ 2.000000000000E+00 1.000000000000E+00 ]

$matrix->applyfunction($coderef)

Applies &$coderef to each element of $matrix, and returns the result. $coderef should be a reference to a subroutine that takes four parameters: ($matrix, $matrix->element($i,$j), $i, $j) where $i and $j are the row and column indices of the current element.

Example:

sub increment {
my ($matrix,$element, $i,$j)=@_;
return $element+1;
}

$A = Math::MatrixReal->new_from_cols([[1,0],[0,1]]);

$E=$A->applyfunction(&increment);
print $E;
[ 2.000000000000E+00 1.000000000000E+00 ]
[ 1.000000000000E+00 2.000000000000E+00 ]
$matrix->largeexponential($exponent)

Finds $matrix^$exponent using the square-and-multiply method. $matrix must be square and $exponent must be a positive integer. Much more efficient for large $exponent than $matrix->$exponential($exponent) in that approximately log2($exponent) multiplications are required instead of approximately $exponent.

$matrix->fill($const);

Sets all elements of $matrix equal to $const.

Example:

$A = new Math::MatrixReal(3,3);
$A->fill(4);
print $A;
[ 4.000000000000E+00 4.000000000000E+00 4.000000000000E+00 ]
[ 4.000000000000E+00 4.000000000000E+00 4.000000000000E+00 ]
[ 4.000000000000E+00 4.000000000000E+00 4.000000000000E+00 ]
$new_matrix = $some_matrix->newfill($rows,$columns,$const); $new_matrix = Math::MatrixReal->newfill($rows,$columns,$const);

Creates a new matrix of the specified size, all the elements of which are $const.

Example:

$A = Math::MatrixReal->newfill(3,3,4);
print $A;
[ 4.000000000000E+00 4.000000000000E+00 4.000000000000E+00 ]
[ 4.000000000000E+00 4.000000000000E+00 4.000000000000E+00 ]
[ 4.000000000000E+00 4.000000000000E+00 4.000000000000E+00 ]

OriginalSynth project allows users to manipulate a small portion of a sound wave (one 44th approximately or 1000/44100 of a second).

This is commonly referred to as a "wave table". Users can manipulate the wave table itself by drawing a line with two end points, drawing a point, drawing a curve, moving a point, or deleting a point. What the user makes is then repeated (oscillated) and sounds pitched.

Additonal features include the ability to combine multiple wave tabs (add/multiply), insert typical waves (sine, square, etc.), make pitch variations, and make duration variations.