Free teamsters union software for linux

Tableutil is a utility for converting, aggregating and performing operations (currently unions, differences, complements and intersections) on lists of IP-addresses. Tableutils primary use is to convert files into a format pfctl(8) can read, but if you find another use for it Id really like to know about it.
It can read plain-text-files with ranges (12.12.12.12-23.23.23.23), CIDR-style networks (192.168.0.0/24) single addresses (242.242.242.242) or hostnames (one.two.com). It can also read p2b-files, the preferred file-format(s) of PeerGuardian. Tableutil has two modes of operation: Quick mode, which is used for converting files to pfctl-compatible tables and advanced mode, which is used to perform more advanced operations on files, and for greater flexibility of the output format.
For example, if you have three files, block1, block2 and exceptions that is to be used in a table that blocks the hosts in block1 and block2, excepting the ranges in exceptions, create a file looking something like this:
# cat blockspec
$block1 = load(text, "block1"); # The block1-blocklist
$block2 = load(text, "block2"); # The block2-blocklist
$exceptions = load(text, "exceptions"); # List of exceptions
$block = difference(union($block1, $block2), $exceptions);
save(cidr, "blocklist", $block);
Or, if you just want to load a peerguardian blocklist (the text-kind), do something like this:
# cat update-blocklist.sh
#! /bin/sh
URL="http://peerguardian.sourceforge.net/lists/ads.php"
rm -f /tmp/blocklist
ftp -V -o - ${URL} 2> /dev/null | gunzip -c - | sed "s/.*:([0-9.-])/1/" |
tableutil -q text 2> /dev/null > /tmp/blocklist
if [ -s /tmp/blocklist ] ; then
mv /etc/pfdata/blocklist /etc/pfdata/blocklist.old &&
cp /tmp/blocklist /etc/pfdata/blocklist &&
pfctl -f /etc/pf.conf -T load
fi
Enhancements:
- A small lexer fix was made to handle different newlines gracefully.

Libunion is a library for manipulating unionfs unions. Libunion is based partly on code from the unionctl tool of the original unionfs project.
This tool is replaced in this package with a version capable of using the library. Command line options for unionctl in this package are identical to those of the original.
Enhancements:
- This is the first proper release of libunion.
- The library is now fully usable, as is the unionctl version included.
- The functions provided by the library are well documented in the manual page, including examples.
- This release has not been extensively tested yet, so it should not be used for anything important.

The Plastic File System project is an LD_PRELOAD module for manipulating what the file system looks like for programs. This allows virtual file systems to exist in user space, without kernel hacks or modules.
PlasticFS includes the following file systems:
chroot
The chroot filter may be used to simulate the effects of the chroot(2) system call, in combination with other filters.
dos
The dos filter may be used to simulate an 8.3 DOS file system.
log
The log filter may be used to transparently log file system access, similar to the strace command.
shortname
The shortname filter may be used to simulate file systems with shorter filenames.
smartlink
The smartlink filter may be used to expand environment variables in symbolic links, using the usual $name notation.
upcase, downcase, titlecase and nocase
The upcase filter to make file names appear to be in upper-case when listed. File names are case- insensitive when being opened, etc. The downcase filetr is similar, except it converts to lower-case, titlecase capitalizes, and nocase is simply case insensitive without altering the filenames.
viewpath
The viewpath filter may be used to make a set of directory trees look like a single directory tree. (Also known as a union file system.) All modifications take place in the first directory in the list.
Aka: union and translucent
Note: Filters may be piped from one to the next, forming powerful combinations.
PlasticFS is currently dependent on the implementation of the GNU C Library. It is self configuring using a GNU Autoconf generated configure script.
Enhancements:
- Build problem fixed.

Ensemblist project is an OpenGL puzzle game.

Ensemblist is a unique reflexion game created for the video game coding compo held in March 2003 in Paris.

In this game, you have to put together several simple geometric primitives to build a given shape. For this, you can move, rotate and compose the primitives with the boolean operators union, intersection and minus. This is building what is called a C.S.G, for Constructive Solid Geometry.

myXTree provides an interface to an SQL tree.
myXTree is an interface to a SQL-tree. It is more about SQL-trees can learn in article SQL for Smarties and Relational Data Structures for Extensible Thesauri. This class allows to save the DOM-document in a SQL-tree and vice versa. For a choice of the data from a SQL-tree are used XPath expressions. Data reading of a SQL-tree can be carried out by two ways: by one SQL-query and recursive way.
The myXTree class use object PEAR::DB and object Document from package myDOM, which goes into package myXML.
Attached to realization of this class used a database mySQL and object PEAR::DB, but this, to regretting, does not do a class lightly bearable on other databases, because in class are used the specialized features mySQL. Because supposed, in the main, use of this class for little renewed data, then was select a tables type MyISAM (unsupported transaction).
A class does not support full features of XPath language. So far does not support an objects selection on namespace prefix; in base saved only the elements, text, CDATA and attributes; use of operator ??? (union) impossible only in recursive method; the XPath functions not implemented.
Enhancements:
- Error handling is completely advanced. PEAR style of error handling is extended with a new class "Error" (see file Error.php for details).
- The code became easier for understanding and for debugging.

Math::NumberCruncher Perl module contains a collection of useful math-related functions.

SYNOPSIS

It should be noted that as of v4.0, there is now an OO interface to Math::NumberCruncher. For backwards compatibility, however, the previous, functional style will always be supported.

# OO Style

use Math::NumberCruncher;

$ref = Math::NumberCruncher->new();

# From this point on, all of the subroutines shown below will be available # through $ref (i.e., ( $high,$low ) = $ref->Range( @array )). For the sake # of brevity, consult the functional documentation (below) for the use # of specific functions.

# Functional Style

use Math::NumberCruncher;

($high, $low) = Math::NumberCruncher::Range(@array);
$mean = Math::NumberCruncher::Mean(@array);
$median = Math::NumberCruncher::Median(@array [, $decimal_places]);
$odd_median = Math::NumberCruncher::OddMedian(@array);
$mode = Math::NumberCruncher::Mode(@array);
$covariance = Math::NumberCruncher::Covariance(@array1, @array2);
$correlation = Math::NumberCruncher::Correlation(@array1, @array2);
($slope, $y_intercept) = Math::NumberCruncher::BestFit(@array1, @array2 [, $decimal_places]);
$distance = Math::NumberCruncher::Distance($x1,$y1,$z1,$x2,$y2,$z2 [, $decimal_places]);
$distance = Math::NumberCruncher::Distance($x1,$y1,$x1,$x2 [, $decimal_places]);
$distance = Math::NumberCruncher::ManhattanDistance($x1,$y1,$x2,$y2);
$probAll = Math::NumberCruncher::AllOf(0.3,0.25,0.91,0.002);
$probNone = Math::NumberCruncher::NoneOf(0.4,0.5772,0.212);
$probSome = Math::NumberCruncher::SomeOf(0.11,0.56,0.3275);
$factorial = Math::NumberCruncher::Factorial($some_number);
$permutations = Math::NumberCruncher::Permutation($n);
$permutations = Math::NumberCruncher::Permutation($n,$k);
$roll = Math::NumberCruncher::Dice(3,12,4);
$randInt = Math::NumberCruncher::RandInt(10,50);
$randomElement = Math::NumberCruncher::RandomElement(@array);
Math::NumberCruncher::ShuffleArray(@array);
@unique = Math::NumberCruncher::Unique(@array);
@a_only = Math::NumberCruncher::Compare(@a,@b);
@union = Math::NumberCruncher::Union(@a,@b);
@intersection = Math::NumberCruncher::Intersection(@a,@b);
@difference = Math::NumberCruncher::Difference(@a,@b);
$gaussianRand = Math::NumberCruncher::GaussianRand();
$ways = Math::NumberCruncher::Choose($n,$k);
$binomial = Math::NumberCruncher::Binomial($attempts,$successes,$probability);
$gaussianDist = Math::NumberCruncher::GaussianDist($x,$mean,$variance);
$StdDev = Math::NumberCruncher::StandardDeviation(@array [, $decimal_places]);
$variance = Math::NumberCruncher::Variance(@array [, $decimal_places]);
@scores = Math::NumberCruncher::StandardScores(@array [, $decimal_places]);
$confidence = Math::NumberCruncher::SignSignificance($trials,$hits,$probability);
$e = Math::Numbercruncher::EMC2( "m512", "miles" [, $decimal_places] );
$m = Math::NumberCruncher::EMC2( "e987432" "km" [, $decimal_places] );
$force = Math::NumberCruncher::FMA( "m12", "a73.5" [, $decimal_places] );
$mass = Math::NumberCruncher::FMA( "a43", "f1324" [, $decimal_places] );
$acceleration = Math::NumberCruncher::FMA( "f53512", "m356" [, $decimal_places] );
$predicted_value = Math::NubmerCruncher::Predict( $slope, $y_intercept, $proposed_x [, $decimal_places] );
$area = Math::NumberCruncher::TriangleHeron( $a, $b, $c [, $decimal_places] );
$area = Math::NumberCruncher::TriangleHeron( 1,3, 5,7, 8,2 [, $decimal_places] );
$perimeter = Math::NumberCruncher::PolygonPerimeter( $x0,$y0, $x1,$y1, $x2,$y2, ... [, p$decimal_places]);
$direction = Math::NumberCruncher::Clockwise( $x0,$y0, $x1,$y1, $x2,$y2 );
$collision = Math::NumberCruncher::InPolygon( $x, $y, @xy );
@points = Math::NumberCruncher::BoundingBox_Points( $d, @p );
$in_triangle = Math::NumberCruncher::InTriangle( $x,$y, $x0,$y0, $x1,$y1, $x2,$y2 );
$area = Math::NumberCruncher::PolygonArea( 0, 1, 1, 0, 2, 0, 3, 2, 2, 3 [, p$decimal_places] );
$area = Math::NumberCruncher::CircleArea( $diameter [, $decimal_places] );
$circumference = Math::NumberCruncher::Circumference( $diameter [, $decimal_places] );
$volume = Math::NumberCruncher::SphereVolume( $radius [, $decimal_places] );
$surface_area = Math::NumberCruncher::SphereSurface( $radius [, $decimal_places] );
$years = Math::NumberCruncher::RuleOf72( $interest_rate [, $decimal_places] );
$volume = Math::NumberCruncher::CylinderVolume( $radius, $height [, $decimal_places] );
$volume = Math::NumberCruncher::ConeVolume( $lowerBaseArea, $height [, $decimal_places] );
$radians = Math::NumberCruncher::deg2rad( $degrees [, $decimal_places] );
$degrees = Math::NumberCruncher::rad2deg( $radians [, $decimal_places] );
$Fahrenheit = Math::NumberCruncher::C2F( $Celsius [, $decimal_places] );
$Celsius = Math::NumberCruncher::F2C( $Fahrenheit [, $decimal_places] );
$cm = Math::NumberCruncher::in2cm( $inches [, $decimal_places] );
$inches = Math::NumberCruncher::cm2in( $cm [, $decimal_places] );
$ft = Math::NumberCruncher::m2ft( $m [, $decimal_places] );
$m = Math::NumberCruncher::ft2m( $ft [, $decimal_places] );
$miles = Math::NumberCruncher::km2miles( $km [, $decimal_places] );
$km = Math::NumberCruncher::miles2km( $miles [, $decimal_places] );
$lb = Math::NumberCruncher::kg2lb( $kg [, $decimal_places] );
$kg = Math::NumberCruncher::lb2kg( $lb [, $decimal_places] );
$RelativeStride = Math::NumberCruncher::RelativeStride( $stride_length, $leg_length [, $decimal_places] );
$RelativeStride = Math::NumberCruncher::RelativeStride_2( $DimensionlessSpeed [, $decimal_places] );
$DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed( $RelativeStride [, $decimal_places] );
$DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed_2( $ActualSpeed, $leg_length [, $decimal_places]);
$ActualSpeed = Math::NumberCruncher::ActualSpeed( $leg_length, $DimensionlessSpeed [, $decimal_places] );
$eccentricity = Math::NumberCruncher::Eccentricity( $half_major_axis, $half_minor_axis [, $decimal_places] );
$LatusRectum = Math::NumberCruncher::LatusRectum( $half_major_axis, $half_minor_axis [, $decimal_places] );
$EllipseArea = Math::NumberCruncher::EllipseArea( $half_major_axis, $half_minor_axis [, $decimal_places] );
$OrbitalVelocity = Math::NumberCruncher::OrbitalVelocity( $r, $a, $M [, $decimal_places] );
$sine = Math::NumberCruncher::sin( $x [, $decimal_places] );
$cosine = Math::NumberCruncher::cos( $x [, $decimal_places] );
$tangent = Math::NumberCruncher::tan( $x [, $decimal_places] );
$arcsin = Math::NumberCruncher::asin( $x [, $decimal_places] );
$arccos = Math::NumberCruncher::acos( $x [, $decimal_places] );
$arctan = Math::NumberCruncher::atan( $x [, $decimal_places] );
$cotangent = Math::NumberCruncher::cot( $x [, $decimal_places] );
$arccot = Math::NumberCruncher::acot( $x [, $decimal_places] );
$secant = Math::NumberCruncher::sec( $x [, $decimal_places] );
$arcsec = Math::NumberCruncher::asec( $x [, $decimal_places] );
$cosecant = Math::NumberCruncher::csc( $x [, $decimal_places] );
$arccosecant = Math::NumberCruncher::acsc( $x [, $decimal_places] );
$exsecant = Math::NumberCruncher::exsec( $x [, $decimal_places] );
$versine = Math::NumberCruncher::vers( $x [, $decimal_places] );
$coversine = Math::NumberCruncher::covers( $x [, $decimal_places] );
$haversine = Math::NumberCruncher::hav( $x [, $decimal_places] );
$grouped = Math::NumberCruncher::Commas( $number );
$SqrRoot = Math::NumberCruncher::SqrRoot( $number [, $decimal_places] );
$square_root = Math::NumberCruncher::sqrt( $x [, $decimal_places] );
$root = Math::NumberCruncher::Root( 55, 3 [, $decimal_places] );
$root = Math::NumberCruncher::Root2( 55, 3 [, $decimal_places] );
$log = Math::NumberCruncher::Ln( 100 [, $decimal_places] );
$log = Math::NumberCruncher::log( $num [, $decimal_places] );
$num = Math::NumberCruncher::Exp( 0.111 [, $decimal_places] );
$num = Math::NumberCruncher::exp( $log [, $decimal_places] );
$Pi = Math::NumberCruncher::PICONST( $decimal_places );
$E = Math::NumberCruncher::ECONST( $decimal_places );
( $A, $B, $C ) = Math::NumberCruncher::PythagTriples( $x, $y [, $decimal_places] );
$z = Math::NumberCruncher::PythagTriplesSeq( $x, $y [, $decimal_places] );
@nums = Math::NumberCruncher::SIS( [$start, $numbers, $increment] );
$inverse = Math::NumberCruncher::Inverse( $number [, $decimal_places] );
@constants = Math::NumberCruncher::CONSTANTS( all [, $decimal_places] );
$bernoulli = Math::NumberCruncher::Bernoulli( $num [, $decimal_places] );
@bernoulli = Math::NumberCruncher::Bernoulli( $num );

Gestinanna::Util Perl module contains utility functions.

SYNOPSIS

use Gestinanna::Util qw(:path);

my $regex = path2regex($path)
my $cmp = path_cmp($path_a, $path_b);

use Gestinanna::Util qw(:hash);

my $new_hash = deep_merge_hash(@hashes);

This module provides utility functions that have no better place to be. Sets of utility functions may be imported by specifying their tags.

:path

Imports: path2regex, path_cmp

PATHS

Paths are made up of a sub-set of the XPath language:

/

The slash (/) is the component separator. Alone, it describes the root of the
resource heirarchy.

//

The double slash (//) stands in place of any number of components (zero or more). Alone, it matches any possible path that does not specify attributes or a final component. To match any component with any attributes, use //*|//*@*.

@

The at sign (@) is the attribute separator. A path should only have one. It separates the final component from any attribute. If no attribute follows it, it stands for the general collection of attributes for an object.

|

The pipe symbol (|) separates paths which together specify a union.

&

The ampersand (&) separates paths which together specify an intersection. Intersection has higher precedence to union. For example, the path //a/* & //*@name | //b/* is considered to be (//a/* & //*@name) | //b/*, not //a/* & (//*@name | //b/*). There are no parenthesis for grouping in actual path expressions.

!

An odd number of initial bangs (!) will negate the following clause, up to a pipe (|) or ampersand (&). An even number of initial bangs will have no effect.

Examples:

The following are some examples of paths.

//*

This matches any path. Attaching attributes to this path will apply them to all objects.

//*@name

This matches the name attribute of all objects.

//*/*

This matches any component that is not at the top-level.

!//a//* & //b//*

This matches any path that has a b component and not an a component.