Free alphaville ft software for linux

Glibc uses locale (or fdcc) files to define cultural conventions. The files are usualy named
xx_ZZ where xx is the ISO language code and ZZ is the ISO country code.
Main features:
- highlights only valid keys with various LC_ sections
- Shows bad < UNNNN > unicode as an error
Installation
- Copy the file to your .vim/syntax directory in a locale file type: set syntax=fdcc
Filetype detection
Slightly harder as locale files do not have any specific suffix - but heres what to do
Insert this after the Diff section in your scripts.vim file. It does initial patern matching and then looks within the file to determine if it is a locale file.
The double quotes below are escaped on this site so remove those escapes. In fact it will probably mess up all back slashes aswell.
" CVS diff
else
let lnum = 1
while getline(lnum) =~ "^? " && lnum < line("$")
let lnum = lnum + 1
endwhile
if getline(lnum) =~ ^Index:s+f+$
set ft=diff
" locale input files: Formal Definitions of Cultural Conventions
" filename must be like en_US, fr_FR@euro or en_US.UTF-8
"elseif expand("%") =~ (ll_uu($|[.@])|i18n|POSIX|translit_*)
elseif expand("%") =~ aa_aa($|[.@])|i18n$|POSIX$|translit_
let lnum = 1
while lnum < 100 && lnum < line("$")
if getline(lnum) =~ ^LC_(IDENTIFICATION|CTYPE|COLLATE|MONETARY|NUMERIC|TIME|MESSAGES|PAPER|TELEPHONE|MEASUREMENT|NAME|ADDRESS)$
setf fdcc
break
endif
let lnum = lnum + 1
endwhile
endif
endif
unlet s:line2 s:line3 s:line4 s:line5
endif

Open MPI is a project combining technologies and resources from several other projects (FT-MPI, LA-MPI, LAM/MPI, and PACX-MPI) in order to build the best MPI library available.
A completely new MPI-2 compliant implementation, Open MPI offers advantages for system and software vendors, application developers and computer science researchers.
Main features:
- Full MPI-2 standards conformance
- Thread safety and concurrency
- Dynamic process spawning
- High performance on all platforms
- Reliable and fast job management
- Network and process fault tolerance
- Support data and network heterogeneity
- Single library supports all networks
- Run-time instrumentation
- Many job schedulers supported
- Many OSs supported (32 and 64 bit)
- Production quality software
- Portable and maintainable
- Tunable by installers and end-users
- Extensive user and installer guides
- Internationalized error messages
- Component-based design, documented APIs
- CPAN-like tool for component management
- Active, responsive mailing list
- Open source license based on the BSD license
The organizations (and newly-combined projects) contributing to Open MPI are Indiana University (LAM/MPI), the University of Tennessee (FT-MPI), and Los Alamos National Laboratory (LA-MPI).
Additional collaborators are at Sandia National Laboratories and the High Performance Computing Center at Stuttgart. These developers bring many years of combined experience to the project.
Enhancements:
- This release fixes handling of $CC when it contains directory names.
- It fixes Fortran 90 status array dimensions, and fixes some compiler warnings.
- pbs-config is used if it can be found, and the rsh launcher is slightly more robust.
- The btl_openib_ib_pkey_value MCA parameter has been added.

Class::DBI::Plugin::FilterOnClick is a Perl module to generate browsable and searchable HTML Tables using FilterOnClick in conjunction with Class::DBI.

SYNOPSIS

# Inside of your sub-class of Class::DBI add these lines:
use Class::DBI::Plugin::FilterOnClick;
use Class::DBI::Pager;
use Class::DBI::AbstractSearch;
use Class::DBI::Plugin::AbstractCount;
use Class::DBI::Plugin::RetrieveAll;

.....

# Inside your script you will be able to use this modules
# methods on your table class or object as needed.

use ClassDBIBaseClass;
use URI::Escape;
use CGI;

my $cgi = CGI->new();

my %params;

map { $params{$_} =
uri_unescape($cgi->param("$_"))
} $cgi->param();

my $filteronclick = Baseball::Master->filteronclick(
-config_file => /srv/www/cgi-bin/baseball.ini,
# -rows => $cgi->param(rows) || 15 ,
-on_page => $cgi->param(page) || 1,
-params => %params );

$filteronclick->field_to_column(
lastname => Last Name . $html->order_by_link(lastname),
firstname => First Name . $html->order_by_link(firstname),
bats => Bats,
throws => Throws,
ht_ft => Height Ft,
ht_in => In,
wt => Weight,
birthyear => Birthyear,
birthstate => Birthstate,
_FilterOnClickCustom1_ => Other Data,
_FilterOnClickCustom2_ => More Data
);

FilterOnClickCustom

$filteronclick->data_table->addRow(
Last Name,
First Name,
Bats ,
Throws ,
Height (ft),
(inches),
Weight,
Birth Year );

$filteronclick->params( $cgi->Vars; );
$filteronclick->exclude_from_url([ page ]);

# indicate which columns to exclude, inverse of display above
# can be set in config file as well
$filteronclick->exclude_columns();

# indicate the base class to work with, this is optional,
# if you should create you object via a call to
# Class::DBI::Plugin::FilterOnClick vs. a Class::DBI sub class
# this assures the correct sub class is used for data collection
$filteronclick->cdbi_class( Baseball::Master );

# indicate the style of navigation to provide
$filteronclick->navigation_style( both );

print qq~ Filter by First Letter of Last Name ~;

print $filteronclick->string_filter_navigation(
-column => lastname,
-position => begins,
);

print qq~ ~;

$filteronclick->only(firstname);


print $filteronclick->build_table(

_FilterOnClickCustom1_ => sub {
my $pid = shift; # pid = Primary ID of the record in the base table
my @status_objects = Baseball::Allstars->search(lahmanid => $pid);
if (@status_objects) {
my $years;
foreach my $st (@status_objects) {
$years .= $st->year() . " ";
}
return $years;
}
return NA;
},

_FilterOnClickCustom2_ => sub {
my $pid = shift; # pid = Primary ID of the record in the base table
my @status_objects = Baseball::Allstars->search(lahmanid => $pid);
if (@status_objects) {
my $teams;
foreach my $st (@status_objects) {
$teams .= $st->team() . " ";
}
return $teams;
}
return NA;
},
);

my $nav = $filteronclick->html_table_navigation();

print qq! n!;

$filteronclick->add_bottom_span($nav);

print $filteronclick->data_table;

UPGRADE WARNING

As of the .8 release there have been changes to the methods and how they work. It is likely that scripts built with older versions WILL break. Please read below to find specific changes that may negatively impact scripts built using the the releases prior to .8. The 1.0 release contains some minor modifications that could in some chases break your scripts, test carefully before upgrading in a production environment.

The intention of this module is to simplify the creation of browsable and searchable HTML tables without having to write the HTML, either in your script or in templates.
It is intended for use inside of other frameworks such as Embperl, Apache::ASP or even CGI. It does not aspire to be its own framework. If you are looking for a frameworks which allow using Class::DBI I suggest you look into the Maypole or the Catalyst module.

See FilterOnClick below for more on the purpose of this module.

Tables are created using HTML::Table. The use of HTML::Table was selected because it allows for several advanced sorting techniques that can provide for easy manipulation of the data outside of the SQL statement. This is very useful in scenarios where you want to provide/test a sort routine and not write SQL for it. The more I use this utility the less likely it seems that one would need to leverage this, but it is an option if you want to explore it.

Feedback on this module, its interface, usage, documentation etc. is welcome.

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 );