Free 0.21 cm is equal to how many inches software for linux

cm Compilation Manager is a new tool for build automation and compilation management. cm Compilation Manager addresses a number of shortcomings I see in make.
Main features:
- A clean syntax based on a context-free language description
- Whitespace insensitivity
- Distinct macros and variables
- Separate procedure and production namespaces
- Many native programming constructs such as foreach loops for easy iteration, and more powerful tools such as anonymous functions with static scoping.
- Built-in support for recursive directory handling without additional invocations of cm.
- An intelligent, automatic configuration file generator
- Pre-generated functions for handling common build tasks in a platform-independent manner
- Support for multiple build configurations and multi-pass builds over complicated directory hierarchies
Installation instructions:
Download cm, classib, and gc.
Install the garbage collector per the included instructions. (Basically ./configure; make; sudo make install.) When running configure, you will need to pass it the parameters: --prefix=/usr/lib --with-threads=posix.
Unzip classlib (tar vzxf classlib.tar.gz).
Configure classlibs Makefile with any paths you need to modify.
Build and install classlib with make && sudo make install.
Unzip cm (tar vzxf cm.tar.gz).
Build and install cm with make && sudo make install.
Configure cm by executing: cd /usr/local/etc && sudo cminit
To verify your cm installation, you can rebuild it with the included Cmrules files by typing cm @clean && cm -m opt in the same directory you built cm in with make.
Enhancements:
- The license was changed to the GPL.
- This release includes a dynamic module/plugin system and two initial plugin modules.
- It supports non-root installation, additional command line options, and caches parsed files for quick retrieval during multi-pass builds.
- Several bugfixes are also included.

Kid-Safe LiveCD is the perfect way for young children to learn about computers.
First, since the entire system runs off of a read-only CD-ROM, parents can let their childeren play on the computer without having to worry about their primary desktop being altered or damaged.
Also, this CD has a content filtering system installed to keep your kids safe on the internet. The filters are setup for a target audience of pre-school and elementary school children. Even so, you should still monitor your child while on the internet.
This system also has lots of games and educational software installed. And even though theyre geared toward children, I guarantee youll enjoy playing with this system as well!
This CD has been built entirely from free software! Most software on this disk is freely available, open source software. A few are not open source, but are freely distributable.
This CD is still in its development stages, so keep an eye out for new versions.
Enhancements:
- Fixed bug in installer
- Installed latest updates from repository
- LBreakout2 is in the penalty box for bad language (Note: LBreakout will be back next version, without the bad language)

Continuus is a Perl interface to Continuus CM.

SYNOPSIS

use Continuus;

Check out a file:

use Continuus;

$ccm = new Continuus;

$ccm->start(database => /proj/Continuus4/rig,
host => stoxserv01);

$ccm->checkOut(file => main.c,
version => 2);

$ccm->stop();

METHODS

new:

The new method creates a new Continuus object.
start:
The start method starts a new Continuus session.

Parameters:

database: Database to open.

host: Hostname to start the engine on.

iniFile: Ini file to read.

Example:

$ccm->start(database => "/proj/Continuus0/rig/", host => "stoccm01");
command:
The command method acts as a interface to all other Continuus functions
not implemented in the Continuus module.

Parameters:

command: The command to be executed by Continuus

Example:

$ccm->command(status);
stop:
The stop command quits the current Continuus session.

Parameters:

None.
query:
The query command is a interface to the Continuus query command.

Parameters:

query: The query string
flags: Flags to pass to Continuus.
Format: Formatting options.

Example:

$ccm->query(query => "status=released", flags => "-u", format => "%objectname");
checkOut:
Checks out a file.

Parameters:

file: The file to check out.
version: The version to set on the new file.

Example:

$ccm->checkOut(file => "main.c", version => "1.1");
checkIn:
Checks in a file.

Parameters:

file: The file to check out.
comment: The comment to set on the new file.

Example:

$ccm->checkIn(file => "main.c", comment => "Created");
reconfigure:
Reconfigure command

Parameters:

project: The project to reconfigure.
parameters: Other parameters to pass to the reconfigure command.

Example:

$ccm->checkOut(file => "main.c", version => "1.1");
debugOn:
Sets the debugging information on.
debugOff:
Sets the debugging information off.

Math::MagicSquare is a Magic Square Checker and Designer.

SYNOPSIS

use Math::MagicSquare;

$a= Math::MagicSquare -> new ([num,...,num],
...,
[num,...,num]);
$a->print("string");
$a->printhtml();
$a->printimage();
$a->check();
$a->rotation();
$a->reflection();

The following methods are available:

new

Constructor arguments are a list of references to arrays of the same length.

$a = Math::MagicSquare -> new ([num,...,num],
...,
[num,...,num]);

check

This function can return 4 value

0: the Square is not Magic
1: the Square is a Semimagic Square (the sum of the rows and the columns is equal)
2: the Square is a Magic Square (the sum of the rows, the columns and the diagonals is equal)
3: the Square ia Panmagic Square (the sum of the rows, the columns, the diagonals and the broken diagonals is equal)

print

Prints the Square on STDOUT. If the method has additional parameters, these are printed before the Magic Square is printed.

printhtml

Prints the Square on STDOUT in an HTML format (exactly a inside a TABLE)

printimage

Prints the Square on STDOUT in png format.

rotation

Rotates the Magic Square of 90 degree clockwise

reflection

Reflect the Magic Square

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

VCS::CMSynergy is a Perl interface to Telelogic SYNERGY/CM (aka Continuus/CM).

SYNOPSIS

use VCS::CMSynergy;

$ccm = VCS::CMSynergy->new(%attr);

($rc, $out, $err) = $ccm->ccm($ccm_command, @ccm_args);
($rc, $out, $err) = $ccm->any_ccm_command(@ccm_args);

$ary_ref = $ccm->query(@ccm_args);
$ary_ref = $ccm->query_arrayref($query, @keywords);
$ary_ref = $ccm->query_hashref($query, @keywords);
$ary_ref = $ccm->query_object($query, @keywords);

$ary_ref = $ccm->finduse(@args);
$path = $ccm->findpath($file_spec, $proj_vers);

$ary_ref = $ccm->history(@ccm_args);
$ary_ref = $ccm->history_arrayref($file_spec, @keywords);
$ary_ref = $ccm->history_hashref($file_spec, @keywords);

$ary_ref = $ccm->ls(@ccm_args);
$ary_ref = $ccm->ls_object($file_spec);
$ary_ref = $ccm->ls_arrayref($file_spec, @keywords);
$ary_ref = $ccm->ls_hashref($file_spec, @keywords);

$value = $ccm->get_attribute($attr_name, $file_spec);
$ccm->set_attribute($attr_name, $file_spec, $value);
$hash_ref = $ccm->list_attributes($file_spec);

$delim = $ccm->delimiter;
$database = $ccm->database;
$ENV{CCM_ADDR} = $ccm->ccm_addr;

This synopsis only lists the major methods.

Methods that dont need a CM Synergy session are described in VCS::CMSynergy::Client. In fact, VCS::CMSynergy is derived from VCS::CMSynergy::Client.

Methods for administering users and their roles are described in VCS::CMSynergy::Users.

Smart Sharpening plugin is a method of sharpening, which sharpens only the edges in the image. This way the noise in the larger smooth parts doesnt get amplified as it does when using regular unsharp mask.

You can find more details on smart sharpening here at gimpguru.org.

Notice that the amount of sharpness is equal, but there is notably less noise. You can see that especially, when you look the hand of the guitar player.

Math::Cephes::Matrix is a Perl interface to the cephes matrix routines.

SYNOPSIS

use Math::Cephes::Matrix qw(mat);
# mat is a shortcut for Math::Cephes::Matrix->new
my $M = mat([ [1, 2, -1], [2, -3, 1], [1, 0, 3]]);
my $C = mat([ [1, 2, 4], [2, 9, 2], [6, 2, 7]]);
my $D = $M->add($C); # D = M + C
my $Dc = $D->coef;
for (my $i=0; $inew($arr_ref);

where $arr_ref is a reference to an array of arrays, as in the following example:

$arr_ref = [ [1, 2, -1], [2, -3, 1], [1, 0, 3] ]

which represents
/ 1 2 -1
| 2 -3 1 |
1 0 3 /

A copy of a Math::Cephes::Matrix object may be done as

my $M_copy = $M->new();

Methods

coef: get coefficients of the matrix

SYNOPSIS:

my $c = $M->coef;

DESCRIPTION:

This returns an reference to an array of arrays containing the coefficients of the matrix.
clr: set all coefficients equal to a value.

SYNOPSIS:

$M->clr($n);

DESCRIPTION:

This sets all the coefficients of the matrix identically to $n. If $n is not given, a default of 0 is used.
add: add two matrices

SYNOPSIS:

$P = $M->add($N);

DESCRIPTION:

This sets $P equal to $M + $N.
sub: subtract two matrices

SYNOPSIS:

$P = $M->sub($N);

DESCRIPTION:

This sets $P equal to $M - $N.
mul: multiply two matrices or a matrix and a vector

SYNOPSIS:

$P = $M->mul($N);

DESCRIPTION:

This sets $P equal to $M * $N. This method can handle matrix multiplication, when $N is a matrix, as well as matrix-vector multiplication, where $N is an array reference representing a column vector.
div: divide two matrices

SYNOPSIS:

$P = $M->div($N);

DESCRIPTION:

This sets $P equal to $M * ($N)^(-1).
inv: invert a matrix

SYNOPSIS:

$I = $M->inv();

DESCRIPTION:

This sets $I equal to ($M)^(-1).
transp: transpose a matrix

SYNOPSIS:

$T = $M->transp();

DESCRIPTION:

This sets $T equal to the transpose of $M.
simq: solve simultaneous equations

SYNOPSIS:

my $M = Math::Cephes::Matrix->new([ [1, 2, -1], [2, -3, 1], [1, 0, 3]]);
my $B = [2, -1, 10];
my $X = $M->simq($B);
for (my $i=0; $inew([ [1, 2, 3], [2, 2, 3], [3, 3, 4]]);
my ($E, $EV1) = $S->eigens();
my $EV = $EV1->coef;
for (my $i=0; $i[$i]->[$j];
}
print "The eigenvector is @$vn";
}

where $M is a Math::Cephes::Matrix object representing a real symmetric matrix. $E is an array reference containing the eigenvalues of $M, and $EV is a Math::Cephes::Matrix object representing the eigenvalues, the ith row corresponding to the ith eigenvalue.

DESCRIPTION:

If M is an N x N real symmetric matrix, and X is an N component column vector, the eigenvalue problem

M X = lambda X

will in general have N solutions, with X the eigenvectors and lambda the eigenvalues.