Free division software for linux

The CWP/SU Seixmic Un*x (SU) package is a software environment for seismic processing and seismic and wave-propagation related research.
Seismic Unix project is used not only in seismology but in other areas involving time-dependent data, such as Ground Penetrating RADAR.
Installation:
1) read the READMEs before unbundling cwp.su.all.xx.tar.Z
2) dont install as root (the superuser) (It is possible to damage a systems file structure if the install is not done properly.)
3) begin with the compressed tarfile cwp.su.all.xx.tar.Z in /your/root/path
4) set the CWPROOT environment variable to CWPROOT=/your/root/path
5) put /your/root/path/bin on your working shell path
6) uncompress and untar the compressed tarfile via:
zcat cwp.su.all.xx.tar.Z | tar -xvf -
The code will appear as the single directory /your/root/path/src
7) compile codes via:
cd /your/root/path/src
1) edit the file /your/root/path/src/Makefile.config to agree with the needs of your system.
2) type:
make install (to install the basic set of codes)
make xtinstall (to install the X-toolkit applications)
make finstall (to install the Fortran codes)
make mglinstall (to install the Mesa/ Open GL items) (experimental)
make utils (to install libcwputils) (nonessential)
make xminstall (to install the Motif application)(nonessential)
make sfinstall (to install an improved version of SEGDREAD)
or if remaking:
type: make remake (to remake the basic set of codes)
make xtremake (to remake the X-toolkit applications)
make finstall (to install the Fortran codes)
make mglremake (to install the Mesa/ Open GL items)(experimental)
make uremake (to remake libcwputils.a)(nonessential)(nonessential)
make xmremake (to remake the Motif-based applications)(nonessential)
make sfremake (to remake the improved version of SEGDREAD)
You may have to do some hacking along the way, if the codes fail to compile the first time through. In this event, you may simply type "make" in the directory where you were modifying code. If code appears to have been missed, you may need to
use the "remaking" options.
A screen dump of a successfull install of the current version of the codes on a RedHat Linux based PC is located in the file: "install.successfull"
Enhancements:
- This version added functions for converting stiffnesses to velocities, replacing lobes on seismic data with a spike of height scaled by the area of the lobe, and carrying out deconvolution by complex division in the frequency domain.
- There were also many code speedups, cleanups, and bugfixes.

Podius is a content management and web publishing system.
Main features:
- o dependencies (download and run anywhere with perl installed)
- intuitive component model with rich configurable properties
- file-based or rdbms-based persistence and high level transactions
- support for concurrency and auto-merged changes (optimistic locking)
- nice and powerful template syntax, easily extensible
- support for multilingual content, synchronized between languages
- support for inheritable and reusable projects
- clean storage-data division (no sql in perl code is needed)
- clean data-presentation division (no perl code in html is needed)
- management scripts, allowing full control from command line
- web-based interface for non-technical editors

BigInteger is an arbitrary length integer extension module for Perl.

SYNOPSIS

use Math::BigInteger;

The BigInteger extension module gives access to Eric Youngs bignum library. This provides a faster alternative to the Math::BigInt library.
The basic object in this library is a BigInteger. It is used to hold a single large integer.

It is not intended that this package be used directly, but instead be used by a wrapper package, such as the Math::BigInteger class.

FUNCTIONS

Many of the following functions can be used in two styles, by calling the function on an object, or by calling the function explicitly; for example, here are two ways of assigning to $a the sum of $b and $c:

$a->add($b, $c);
or

BigInteger::add($a, $b, $c);

Creation/Destruction routines.

new
my $bi = new BigInteger; # Create a new BigInteger object.
clone
my $b = $a->clone();

Create a new BigInteger object from another BigInteger object.

copy
copy($a, $b);

Copy one BigInteger object to another.

save
my $data = $bi->save();

Save a BigInteger object as a MSB-first string.

restore
my $bi = restore BigInteger $data;

Create a new BigInteger object from a MSB-first string.

Comparison functions

ucmp
ucmp($a, $b);

Return -1 if $a is less than $b, 0 if $a and $b are the same and 1 is $a is greater than $b. This is an unsigned comparison.

cmp
cmp($a, $b);

Return -1 if $a is less than $b, 0 if $a and $b are the same and 1 is $a is greater than $b. This is a signed comparison.

Arithmetic Functions

inc $bi->inc();

Increment $bi by one:

dec $bi->dec();

Decrement $bi by one:

add
$r->add($a, $b);

Add $a and $b and return the result in $r.

mul
$r->mul($a, $b);

Multiply $a by $b and return the result in $r. Note that $r must not be the same object as $a or $b.

div
div($dv, $rem, $m, $d);

Divide $m by $d and return the result in $dv and the remainder in $rem. Either of $dv or $rem can be undef, in which case that value is not returned.

mod
$rem->mod($m, $d);

Find the remainder of $m divided by $d and return it in $rem. This function is more efficient than div.

lshift
$r->lshift($a, $n);

Shift $a left by $n bits.

lshift1
$r->lshift1($a);

Shift $a left by 1 bit. This form is more efficient than lshift($r, $a, 1).

rshift
$r->rshift($a, $n);

Shift $a right by $n bits.

rshift1
$r->rshift1($a);

Shift $a right by 1 bit. This form is more efficient than rshift($r, $a, 1).

mod_exp
$r->mod_exp($a, $p, $mod);

Raise $a to the $p power and return the remainder into $r when divided by $m.

modmul_recip
modmul_recip($r, $x, $y, $m, $i, $nb);

This function is used to perform an efficient mod_mul operation. If one is going to repeatedly perform mod_mul with the same modulus is worth calculating the reciprocal of the modulus and then using this function. This operation uses the fact that a/b == a*r where r is the reciprocal of b. On modern computers multiplication is very fast and big number division is very slow. $x is multiplied by $y and then divided by $m and the remainder is returned in $r. $i is the reciprocal of $m and $nb is the number of bits as returned from reciprocal. This function is used in mod_exp.

mul_mod
$r->mul_mod($a, $b, $m);

Multiply $a by $b and return the remainder into $r when divided by $m.
reciprical
$r->reciprical($m);

Return the reciprocal of $m into $r.

Miscellaneous Routines

num_bits
my $size = $bi->numbits();

Return the size (in bits) of the BigInteger.

gcd
$r->gcd($a, $b);

$r has the greatest common divisor of $a and $b.

inverse_modn
$r->inverse_modn($a, $n);

This function creates a new BigInteger and returns it in $r. This number is the inverse mod $n of $a. By this it is meant that the returned value $r satisfies (a*r)%n == 1. This function is used in the generation of RSA keys.

XView4Struts provides a Struts framework extension that replaces JSP pages with pure HTML.
The XView4Struts project is an extension to the Jakarta Struts Framework. Its main purpose is to eliminate the need to use tag libraries and JSP pages. The view is pure HTML, and interaction between the view and the model is transparent to the developer.
This approach offers faster development, better division of work, a more pure MVC design pattern, reusable view components, and easier maintenance.
With XView4Struts the view layer is pure HTML. This has several implications. You dont need a java developer to write HTML. Many organizations have graphics experts that are more suited for that job. Many organizations prefer to create HTML mock-ups of an application to solicit client approval before they start working on the underlying logic that makes it work. Using this scenerio with the standard Struts view layer, the developer then has to spend many hours implementing jsp tags to make it work with the underlying logic. With XView4Struts the developer only needs to apply id attributes to the standard HTML tags and the framework takes care of the rest.
XView4Struts extends the Struts requestProcessor and intercepts all forwarding actions to HTML pages. The processor parses the HTML page and if it can it will process any tags implementing an id attribute. If there is no match between the id attribute and a form bean property or an error occurs, the parser simply returns control back to the processor. Since only HTML pages are parsed, XView4Struts may exist in an application that implements the standard Struts view components.
Main features:
- Faster development time. A whole layer of programming has been removed since there are no JSPs to write. No tag libraries to learn and implement.
- Easier maintenance. There is no logic in the view layer to troubleshoot and maintain.
- A truer MVC design pattern since all logic in the view layer has been removed.
- The developer has an option to use xslt to produce dynamic content. Reusable view components are easy to build using this option. XView4Struts does not use xslt to produce the entire view layer as other implementations of this type do. It is only implemented to dynamically insert content pieces into the HTML document.
- Application templates are extremely easy to implement.
- The parsing functionality is dynamic enough that the developer often has more than one option or technology to choose from to achieve the same result. They simply use what they understand best.
Enhancements:
- Enhancement - Upgraded

Exceptions in C implements fully-functional nested exceptions with these constructs:

try
except
on
throw

Also, it allows to define various datatypes for exception object (default is int, can be anything from char * to struct foo *).

Compiling and running

Precodey straight forward.

admp@sols:~/excc/example$ gcc exception.c -c
admp@sols:~/excc/example$ gcc exception.o example.c -o example
admp@sols:~/excc/example$ ./example
Usage: ./example A B
admp@sols:~/excc/example$ ./example 100 2
100/2=50
Program is going to end its short life.
admp@sols:~/excc/example$ ./example 100 0
Caught up division by zero (100/0).
Program is going to end its short life.

Attributions:

Felix Ogg for inspiring me to write finally, also detailed feedbacks and ideas for documentation (diagrams too!). Though I havent completed that - for almost a year now; I am not sure I ever will.

OpenTT is a trouble ticketing/request management engine, a simple and intuitive container for structured information in the form of question/answer or title/content (FAQ), and a sophisticated graphical reporting tool to keep the situation under control.
Main features:
Trouble Ticketing (based on OTRS)
- Opening of calls via web
- Opening of calls via email
- Opening of calls via telephone through an operator (available integration for CosmoCall and leading multimedia contact center software)
- Management of users, groups and security policies (with local database or LDAP server)
- Management of multiple request queues
- Management of priorities, alarms, ready-made replies
- Resource accounting
- Multilingual support
Frequently asked question (based on phpMyFAQ)
- Division of subjects into categories and sub-categories
- List of the most frequently read articles
- List of most recent articles
- Free text search
- Management of user feedback
Graphical reporting (based on Cewolf)
- Trend graphics
- Dashboard with real time indicators
Enhancements:
- Chart enhancements included an object filter, data download (CSV), and a reset properties button.
- The dashboard was enhanced with an object filter and configurable meter size.
- Database connection optimizations were made and bug related to chart calendars was fixed.

Math::BigInt::Calc is a pure Perl module to support Math::BigInt.

SYNOPSIS

Provides support for big integer calculations. Not intended to be used by other modules. Other modules which sport the same functions can also be used to support Math::BigInt, like Math::BigInt::GMP or Math::BigInt::Pari.

In order to allow for multiple big integer libraries, Math::BigInt was rewritten to use library modules for core math routines. Any module which follows the same API as this can be used instead by using the following:

use Math::BigInt lib => libname;
libname is either the long name (Math::BigInt::Pari), or only the short version like Pari.

METHODS

The following functions MUST be defined in order to support the use by Math::BigInt v1.70 or later:

api_version() return API version, 1 for v1.70, 2 for v1.83
_new(string) return ref to new object from ref to decimal string
_zero() return a new object with value 0
_one() return a new object with value 1
_two() return a new object with value 2
_ten() return a new object with value 10

_str(obj) return ref to a string representing the object
_num(obj) returns a Perl integer/floating point number
NOTE: because of Perl numeric notation defaults,
the _numified obj may lose accuracy due to
machine-dependent floating point size limitations

_add(obj,obj) Simple addition of two objects
_mul(obj,obj) Multiplication of two objects
_div(obj,obj) Division of the 1st object by the 2nd
In list context, returns (result,remainder).
NOTE: this is integer math, so no
fractional part will be returned.
The second operand will be not be 0, so no need to
check for that.
_sub(obj,obj) Simple subtraction of 1 object from another
a third, optional parameter indicates that the params
are swapped. In this case, the first param needs to
be preserved, while you can destroy the second.
sub (x,y,1) => return x - y and keep x intact!
_dec(obj) decrement object by one (input is guaranteed to be > 0)
_inc(obj) increment object by one


_acmp(obj,obj) operator for objects (return -1, 0 or 1)

_len(obj) returns count of the decimal digits of the object
_digit(obj,n) returns the nth decimal digit of object

_is_one(obj) return true if argument is 1
_is_two(obj) return true if argument is 2
_is_ten(obj) return true if argument is 10
_is_zero(obj) return true if argument is 0
_is_even(obj) return true if argument is even (0,2,4,6..)
_is_odd(obj) return true if argument is odd (1,3,5,7..)

_copy return a ref to a true copy of the object

_check(obj) check whether internal representation is still intact
return 0 for ok, otherwise error message as string

_from_hex(str) return new object from a hexadecimal string
_from_bin(str) return new object from a binary string
_from_oct(str) return new object from an octal string

_as_hex(str) return string containing the value as
unsigned hex string, with the 0x prepended.
Leading zeros must be stripped.
_as_bin(str) Like as_hex, only as binary string containing only
zeros and ones. Leading zeros must be stripped and a
0b must be prepended.

_rsft(obj,N,B) shift object in base B by N digits right
_lsft(obj,N,B) shift object in base B by N digits left

_xor(obj1,obj2) XOR (bit-wise) object 1 with object 2
Note: XOR, AND and OR pad with zeros if size mismatches
_and(obj1,obj2) AND (bit-wise) object 1 with object 2
_or(obj1,obj2) OR (bit-wise) object 1 with object 2

_mod(obj1,obj2) Return remainder of div of the 1st by the 2nd object
_sqrt(obj) return the square root of object (truncated to int)
_root(obj) return the nth (n >= 3) root of obj (truncated to int)
_fac(obj) return factorial of object 1 (1*2*3*4..)
_pow(obj1,obj2) return object 1 to the power of object 2
return undef for NaN
_zeros(obj) return number of trailing decimal zeros
_modinv return inverse modulus
_modpow return modulus of power ($x ** $y) % $z
_log_int(X,N) calculate integer log() of X in base N
X >= 0, N >= 0 (return undef for NaN)
returns (RESULT, EXACT) where EXACT is:
1 : result is exactly RESULT
0 : result was truncated to RESULT
undef : unknown whether result is exactly RESULT
_gcd(obj,obj) return Greatest Common Divisor of two objects
The following functions are REQUIRED for an api_version of 2 or greater:
_1ex($x) create the number 1Ex where x >= 0
_alen(obj) returns approximate count of the decimal digits of the
object. This estimate MUST always be greater or equal
to what _len() returns.
_nok(n,k) calculate n over k (binomial coefficient)

The following functions are optional, and can be defined if the underlying lib has a fast way to do them. If undefined, Math::BigInt will use pure Perl (hence slow) fallback routines to emulate these:

_signed_or
_signed_and
_signed_xor

Input strings come in as unsigned but with prefix (i.e. as 123, 0xabc or 0b1101).

So the library needs only to deal with unsigned big integers. Testing of input parameter validity is done by the caller, so you need not worry about underflow (f.i. in _sub(), _dec()) nor about division by zero or similar cases.

The first parameter can be modified, that includes the possibility that you return a reference to a completely different object instead. Although keeping the reference and just changing its contents is preferred over creating and returning a different reference.

Return values are always references to objects, strings, or true/false for comparison routines.

Libeval provides simple means of evaluating simple arithmetic expressions involving literal numeric values, variables and functions using the addition (+), subtraction (-), multiplication (*), division (/), modulo division (), exponentiation (^), sign (+-), percentag (%) and grouping (()) operators.
Libeval provides a means of setting and interrogating variables, defining functions and converting error codes into human readable strings. A number of predefined functions are included with libeval that wrap the existing standard C library math functions.
You can evaluate an expression by calling the eval() function. eval() takes two parameters, the expression to evaluate (as a simple C string) and a reference to a double precision float in which to put the result. If eval() encounters an error it returns a non-zero value, otherwise, if everything went well, it returns zero.
The error code returned by eval() can be converted into a human readable string by the eval_error() function. eval_error() takes one parameter, the error code returned by eval(),and returns a constant string describing the error.
Variables can be manipulated with the eval_set_var() and eval_get_var() functions.
eval_set_var() sets the named variable to the specified double precision value. eval_set_var() takes two parameters, the name of the variable to set as a simple C string, and the double precision float value to set the variable to. it returns 0 (zero) on success, non-zero on failure.
eval_get_var() gets the value of the named variable. eval_get_var() takes two parameters, the name of the variable as a simple C string and a reference to a double precision float in which to store the variables value. it returns 0 (zero) on success, non-zero on failure.
Functions can be defined with the eval_def_fn() function, which takes the name of the function as a simple C string, a pointer to a C function implementing the function, a pointer to a block of custom storage for use by the function and the number of arguments taken by the function. The prototype for the implementation function is:
int fn(int args, double *arg, double *rv, void *data);
The first two parameters (args and arg) are similar to the standard parameters to the main() function in C, the args parameter indicates how many elements are the argument list, and arg is the argument list itself. The third parameter (rv) is the return value from the function. The last parameter (data) is the custome storage block passed in when the function was defined.
If you specify a positive value (including zero) as the number of arguments for a function, libeval will only all the function to be called with exactly that number of parameters. If you specify a -1 (negative one) for the number of arguments, the function can be called with any number of parameters.
The following functions are predefined:
abs(x) absolute value of x
int(x) integer part of x
round(x) round x to nearest integer
trunc(x) truncate x (same as int(x))
floor(x) round x to nearest lesser integer
ceil(x) round x to nearest greater integer
sin(x) sine of x (radians)
cos(x) cosine of x (radians)
tan(x) tangent of x (radians)
asin(x) arc sine of x (radians)
acos(x) arc cosine of x (radians)
atan(x) arc tangent of x (radians)
sinh(x) hyperbolic sine of x (radians)
cosh(x) hyperbolic cosine of x (radians)
tanh(x) hyperbolic tangent of x (radians)
asinh(x) hyperbolic arc sine of x (radians)
acosh(x) hyperbolic arc cosine of x (radians)
atanh(x) hyperbolic arc tangent of x (radians)
deg(x) convert radians to degrees
rad(x) convert degrees to radians
ln(x) natural logarithm of x
log(x) base 10 logarithm of x
sqrt(x) square root of x
exp(x) e to x power
rand() random number between 0.0 and 1.0
fact(x) factorial of x (or gamma(x) if x is non-integer)
sum(...) sum of the arguments
min(...) minimum value in arguments
max(...) maximum value in arguments
avg(...) average of arguments
med(...) median of arguments
var(...) variance of arguments
std(...) standard deviation of arguments
Finally, you can get a set of bookkeepping information about the eval_expr libray with the eval_info() function. eval_info() takes nine parmaeters: three references to integer values for the version, revision and build numbers of the current eval_expr library, and three pairs of buffer address and buffer size limit for authors name, copyright info and license info.
You can use libeval by including the libeval header in your program source
#include
and then by linking your program against the libeval library
gcc -o myprog myprog.c -leval
Enhancements:
- A bug in the var() function and version string construction were fixed.