Free integer software for linux

Solving Constraint Integer Programs is a framework for constraint integer programming. For solving Integer Programs and Constraint Programs, a very similar technique is used: the problem is successively divided into smaller subproblems (branching) that are solved recursively.
On the other hand, Integer Programming and Constraint Programming have different strengths: Integer Programming uses LP relaxations and cutting planes to provide strong dual bounds, while Constraint Programming can handle arbitrary (non-linear) constraints and uses propagation to tighten the variables domains.
SCIP is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as pure MIP solver or as framework for branch-cut-and-price.
Main features:
- It is a framework for branching, cutting, pricing, and propagation.
- It is highly flexible through many possible user plugins:
- constraint handlers to implement arbitrary constraints,
- variable pricers to dynamically create problem variables,
- domain propagators to apply constraint independent propagations on the variables domains,
- cut separators to apply cutting planes on the LP relaxation,
- relaxators to provide relaxations and dual bounds in addition to the LP relaxation,
- primal heuristics to search for feasible solutions with specific support for probing and diving,
- node selectors to guide the search,
- branching rules to split the problem into subproblems,
- presolvers to simplify the solved problem,
- file readers to parse different input file formats,
- event handlers to be informed on specific events, e.g., when a node was solved, a specific variable changed its bounds, or a new primal solution was found,
- display handlers to create additional columns in the solvers output.
- dialog handlers to extend the included command shell.
- Every existing unit is implemented as a plugin, leading to an interface flexible enough to meet the needs of most additional user extensions.
- A dynamic cut pool management is included.
- The user may mix preprocessed and active problem variables in expressions: they are automatically transformed to corresponding active problem variables.
- Arbitrarily many children per node can be created, and the different children can be arbitrarily defined.
- It has an open LP solver support (currently supporting ILOG CPLEX, Dash XPress-MP, SoPlex, and CLP.
- The LP relaxation need not to be solved at every single node (it can even be turned off completely, mimicing a pure constraint solver).
- Additional relaxations (e.g., semidefinite relaxations or Lagrangian relaxations) can be included, working in parallel or interleaved.
- Conflict analysis can be applied to learn from infeasible subproblems.
- Dynamic memory management reduces the number of operation system calls with automatic memory leakage detection in debug mode.
Enhancements:
- The new heuristics "RENS", "mutation", "veclendiving", and "intshifting", were included.
- The existing ones were improved.
- Presolving and c-MIR cut generation were improved.
- A few bugs were fixed.

PDL::LinearAlgebra::Complex is a PDL interface to the lapack linear algebra programming library (complex number).

SYNOPSIS

use PDL::Complex
use PDL::LinearAlgebra::Complex;

$a = r2C random (100,100);
$s = r2C zeroes(100);
$u = r2C zeroes(100,100);
$v = r2C zeroes(100,100);
$info = 0;
$job = 0;
cgesdd($a, $job, $info, $s , $u, $v);

This module provide an interface to parts of the lapack library (complex number). These routine accept either float or double piddles.

EOD

pp_defc("gesvd", HandleBad => 0, RedoDimsCode => $SIZE(r) = $PDL(A)->ndims > 2 ? min($PDL(A)->dims[1], $PDL(A)->dims[2]) : 1;, Pars => [io,phys]A(2,m,n); int jobu(); int jobvt(); [o,phys]s(r); [o,phys]U(2,p,q); [o,phys]VT(2,s,t); int [o,phys]info(), GenericTypes => [F,D], Code => generate_code
integer lwork;
char trau, travt;
types(F) %{

extern int cgesvd_(char *jobu, char *jobvt, integer *m, integer *n, float *a,
integer *lda, float *s, float *u, int *ldu,
float *vt, integer *ldvt, float *work, integer *lwork, float *rwork,
integer *info);
float *rwork;
float tmp_work[2];
%}
types(D) %{

extern int zgesvd_(char *jobz,char *jobvt, integer *m, integer *n,
double *a, integer *lda, double *s, double *u, int *ldu,
double *vt, integer *ldvt, double *work, integer *lwork, double *rwork,
integer *info);
double *rwork;
double tmp_work[2];
%}
lwork = ($PRIV(__m_size) < $PRIV(__n_size)) ? 5*$PRIV(__m_size) : 5*$PRIV(__n_size);
types(F) %{
rwork = (float *)malloc(lwork * sizeof(float));
%}
types(D) %{
rwork = (double *)malloc(lwork * sizeof(double));
%}
lwork = -1;


switch ($jobu())
{
case 1: trau = A;
break;
case 2: trau = S;
break;
case 3: trau = O;
break;
default: trau = N;
}
switch ($jobvt())
{
case 1: travt = A;
break;
case 2: travt = S;
break;
case 3: travt = O;
break;
default: travt = N;
}



$TFD(cgesvd_,zgesvd_)(
&trau,
&travt,
&$PRIV(__m_size),
&$PRIV(__n_size),
$P(A),
&$PRIV(__m_size),
$P(s),
$P(U),
&$PRIV(__p_size),
$P(VT),
&$PRIV(__s_size),
&tmp_work[0],
&lwork,
rwork,
$P(info));

lwork = (integer )tmp_work[0];
{
types(F) %{

float *work = (float *)malloc(2*lwork * sizeof(float));
%}
types(D) %{

double *work = (double *)malloc(2*lwork * sizeof(double));
%}
$TFD(cgesvd_,zgesvd_)(
&trau,
&travt,
&$PRIV(__m_size),
&$PRIV(__n_size),
$P(A),
&$PRIV(__m_size),
$P(s),
$P(U),
&$PRIV(__p_size),
$P(VT),
&$PRIV(__s_size),
work,
&lwork,
rwork,
$P(info));
free(work);
}
free(rwork);
,
Doc=>

Libgcrypt is a general purpose cryptographic library based on the code from GnuPG.

It provides functions for all cryptograhic building blocks:

symmetric ciphers (AES, DES, Blowfish, CAST5, Twofish, Arcfour)
hash algorithms (MD4, MD5, RIPE-MD160, SHA-1, TIGER-192), MACs (HMAC for all hash algorithms)
public key algorithms (RSA, ElGamal, DSA)
large integer functions
random numbers
and a lot of supporting functions.

NativeCall is a Java toolkit that lets you call operating system methods from whithin Java without JNI code.
The current version 0.4.0 supports structs, Strings, primitive types (ints and booleans), byte and char arrays and output parameters.
NativeCall 0.4.0 implements some minor changes to make the API more consistent and easier. NativeCall project also features more unit tests.
Enhancements:
- The previous release could not create multiple pointers correctly.
- Javadoc for Win32Verifier#verifyModuleName(String) was corrected.
- Using a new Holder(null) now means new Holder(new Integer(0)).
- Constructor method IDs are now cached.
- int hashCode() methods have been optimized.

Set::Infinite::Basic is a Perl module with sets of intervals.

SYNOPSIS

use Set::Infinite::Basic;

$set = Set::Infinite::Basic->new(1,2); # [1..2]
print $set->union(5,6); # [1..2],[5..6]

Set::Infinite::Basic is a Set Theory module for infinite sets.

It works on reals, integers, and objects.

This module does not support recurrences. Recurrences are implemented in Set::Infinite.

METHODS

empty_set

Creates an empty_set.

If called from an existing set, the empty set inherits the "type" and "density" characteristics.

universal_set

Creates a set containing "all" possible elements.

If called from an existing set, the universal set inherits the "type" and "density" characteristics.

until

Extends a set until another:

0,5,7 -> until 2,6,10
gives
[0..2), [5..6), [7..10)

Note: this function is still experimental.

copy

clone

Makes a new object from the objects data.

Mode functions:

$set = $set->real;

$set = $set->integer;

Logic functions:

$logic = $set->intersects($b);

$logic = $set->contains($b);

$logic = $set->is_null; # also called "is_empty"

Set functions:

$set = $set->union($b);

$set = $set->intersection($b);

$set = $set->complement;
$set = $set->complement($b); # can also be called "minus" or "difference"

$set = $set->simmetric_difference( $b );

$set = $set->span;

result is (min .. max)

Scalar functions:

$i = $set->min;

$i = $set->max;

$i = $set->size;

$i = $set->count; # number of spans

Overloaded Perl functions:

print

sort,

Global functions:

separators(@i)

chooses the interval separators.

default are [ ] ( ) .. ,.

INFINITY

returns an Infinity number.

NEG_INFINITY

returns a -Infinity number.

iterate ( sub { } )

Iterates over a subroutine.
Returns the union of partial results.

first

In scalar context returns the first interval of a set.

In list context returns the first interval of a set, and the
tail.

Works in unbounded sets

type($i)

chooses an object data type.

default is none (a normal perl SCALAR).

examples:

type(Math::BigFloat);
type(Math::BigInt);
type(Set::Infinite::Date);
See notes on Set::Infinite::Date below.

tolerance(0) defaults to real sets (default)
tolerance(1) defaults to integer sets

real defaults to real sets (default)

integer defaults to integer sets

Internal functions:

$set->fixtype;

$set->numeric;

HTML::Widget is a Perl module with HTML Widget And Validation Framework.

SYNOPSIS

use HTML::Widget;

# Create a widget
my $w = HTML::Widget->new(widget)->method(get)->action(/);

# Add a fieldset to contain the elements
my $fs = $w->element( Fieldset, user )->legend(User Details);

# Add some elements
$fs->element( Textfield, age )->label(Age)->size(3);
$fs->element( Textfield, name )->label(Name)->size(60);
$fs->element( Submit, ok )->value(OK);

# Add some constraints
$w->constraint( Integer, age )->message(No integer.);
$w->constraint( Not_Integer, name )->message(Integer.);
$w->constraint( All, age, name )->message(Missing value.);

# Add some filters
$w->filter(Whitespace);

# Process
my $result = $w->process;
my $result = $w->process($query);


# Check validation results
my @valid_fields = $result->valid;
my $is_valid = $result->valid(foo);
my @invalid_fields = $result->have_errors;
my $is_invalid = $result->has_errors(foo);;

# CGI.pm-compatible! (read-only)
my $value = $result->param(foo);
my @params = $result->param;

# Catalyst::Request-compatible
my $value = $result->params->{foo};
my @params = keys %{ $result->params };

# Merge widgets (constraints and elements will be appended)
$widget->merge($other_widget);

# Embed widgets (as fieldset)
$widget->embed($other_widget);

# Get list of elements
my @elements = $widget->get_elements;

# Get list of constraints
my @constraints = $widget->get_constraints;

# Get list of filters
my @filters = $widget->get_filters;

Create easy to maintain HTML widgets!

Everything is optional, use validation only or just generate forms, you can embed and merge them later.

The API was designed similar to other popular modules like Data::FormValidator and FormValidator::Simple, HTML::FillInForm is also built in (and much faster).

This Module is very powerful, dont misuse it as a template system!

Convert::ASN1 is an ASN.1 Encode/Decode library.

SYNOPSYS

use Convert::ASN1;

$asn = Convert::ASN1->new;
$asn->prepare(q<

[APPLICATION 7] SEQUENCE {
int INTEGER,
str OCTET STRING
}

>);

$pdu = $asn->encode( int => 7, str => "string");

$out = $asn->decode($pdu);
print $out->{int}," ",$out->{str},"n";

use Convert::ASN1 qw(:io);

$peer = asn_recv($sock,$buffer,0);
$nbytes = asn_read($fh, $buffer);
$nbytes = asn_send($sock, $buffer, $peer);
$nbytes = asn_send($sock, $buffer);
$nbytes = asn_write($fh, $buffer);
$buffer = asn_get($fh);
$yes = asn_ready($fh)

Convert::ASN1 encodes and decodes ASN.1 data structures using BER/DER rules.