Free number the stars software for linux

Number::WithError is a Perl module that contains numbers with error propagation and scientific rounding.

SYNOPSIS

use Number::WithError;

my $num = Number::WithError->new(5.647, 0.31);
print $num . "n";
# prints 5.65e+00 +/- 3.1e-01
# (I.e. it automatically does scientific rounding)

my $another = $num * 3;
print $another . "n";
# propagates the error assuming gaussian errors
# prints 1.69e+01 +/- 9.3e-01

# trigonometric functions also work:
print sin($another) . "n";
# prints -9.4e-01 +/- 3.1e-01

my $third = $another ** $num;
print $third. "n";
# propagates both errors into one.
# prints 8.7e+06 +/- 8.1e+06

# shortcut for the constructor:
use Number::WithError witherror;
$num = witherror(0.00032678, [2.5e-5, 3e-5], 5e-6);
# can deal with any number of errors, even with asymmetric errors
print $num . "n";
# prints 3.268e-04 + 2.5e-05 - 3.00e-05 +/- 5.0e-06
# Note: It may be annyoing that they dont all have the same
# exponent, but they *do* all have the sam significant digit!

This class is a container class for numbers with a number of associated symmetric and asymmetric errors. It overloads practically all common arithmetic operations and trigonometric functions to propagate the errors. It can do proper scientific rounding (as explained in more detail below in the documentation of the significant_digit() method).

You can use Math::BigFloat objects as the internal representation of numbers in order to support arbitrary precision calculations.

Errors are propagated using Gaussian error propagation.

With a notable exception, the test suite covers way over ninety percent of the code. The remaining holes are mostly difficult-to-test corner cases and sanity tests. The comparison routines are the exception for which there will be more extensive tests in a future release.

Number::Bytes::Human is a Perl module that can convert byte count to human readable format.

SYNOPSIS

use Number::Bytes::Human qw(format_bytes);
$size = format_bytes(0); # 0
$size = format_bytes(2*1024); # 2.0K

$size = format_bytes(1_234_890, bs => 1000); # 1.3M
$size = format_bytes(1E9, bs => 1000); # 1.0G

# the OO way
$human = Number::Bytes::Human->new(bs => 1000, si => 1);
$size = $human->format(1E7); # 10MB
$human->set_options(zero => -);
$size = $human->format(0); # -

THIS IS ALPHA SOFTWARE: THE DOCUMENTATION AND THE CODE WILL SUFFER CHANGES SOME DAY (THANKS, GOD!).

This module provides a formatter which turns byte counts to usual readable format, like 2.0K, 3.1G, 100B. It was inspired in the -h option of Unix utilities like du, df and ls for "human-readable" output.

From the FreeBSD man page of df: http://www.freebsd.org/cgi/man.cgi?query=df

"Human-readable" output. Use unit suffixes: Byte, Kilobyte,
Megabyte, Gigabyte, Terabyte and Petabyte in order to reduce the
number of digits to four or fewer using base 2 for sizes.

byte B
kilobyte K = 2**10 B = 1024 B
megabyte M = 2**20 B = 1024 * 1024 B
gigabyte G = 2**30 B = 1024 * 1024 * 1024 B
terabyte T = 2**40 B = 1024 * 1024 * 1024 * 1024 B

petabyte P = 2**50 B = 1024 * 1024 * 1024 * 1024 * 1024 B
exabyte E = 2**60 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B
zettabyte Z = 2**70 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B
yottabyte Y = 2**80 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B

I have found this link to be quite useful:

http://www.t1shopper.com/tools/calculate/

If you feel like a hard-drive manufacturer, you can start counting bytes by powers of 1000 (instead of the generous 1024). Just use bs => 1000.

But if you are a floppy disk manufacturer and want to start counting in units of 1024000 (for your "1.44 MB" disks)? Then use bs => 1_024_000.

If you feel like a purist academic, you can force the use of metric prefixes according to the Dec 1998 standard by the IEC. Never mind the units for base 1000 are (B, kB, MB, GB, TB, PB, EB, ZB, YB) and, even worse, the ones for base 1024 are (B, KiB, MiB, GiB, TiB, PiB, EiB, ZiB, YiB) with the horrible names: bytes, kibibytes, mebibytes, etc. All you have to do is to use si => 1. Aint that beautiful the SI system? Read about it:

http://physics.nist.gov/cuu/Units/binary.html

You can try a pure Perl "ls -lh"-inspired command with the one-liner, er, two-liner:

$ perl -MNumber::Bytes::Human=format_bytes
-e printf "%5s %sn", format_bytes(-s), $_ for @ARGV *

Why to write such a module? Because if people can write such things in C, it can be written much easier in Perl and then reused, refactored, abused. And then, when it is much improved, some brave soul can port it back to C (if only for the warm feeling of painful programming).

Number::Phone::IE is a Perl module with Republic of Ireland-specific methods for Number::Phone.
SYNOPSIS
use Number::Phone;
$dermots_phone = Number::Phone->new(IE, 017654321);
METHODS
The following methods from Number::Phone are overridden:
is_valid
The number is valid within the national numbering scheme. It may or may not yet be allocated, or it may be reserved. Any number which returns true for any of the following methods will also be valid.
is_allocated
The number has been allocated to a telco for use. It may or may not yet be in use or may be reserved. Not currently implemented.
is_geographic
The number refers to a geographic area.
is_fixed_line
The number, when in use, can only refer to a fixed line.
is_mobile
The number, when in use, can only refer to a mobile phone.
is_pager
The number, when in use, can only refer to a pager.
is_tollfree
Callers will not be charged for calls to this number under normal circumstances.
is_specialrate
The number, when in use, attracts special rates. For instance, national dialling at local rates, or premium rates for services.
is_adult
The number, when in use, goes to a service of an adult nature, such as porn.
is_network_service
The number is some kind of network service such as a human operator, directory enquiries, emergency services etc
country_code
Returns 353.
regulator
Returns some text in an appropriate character set saying who the telecoms regulator is, with optional details such as their web site or phone number.
areacode
Return the area code - if applicable - for the number. If not applicable, returns undef.
areaname
Return the area name - if applicable - for the number, or undef.
subscriber
Return the subscriber part of the number
operator
Return the name of the telco operating this number, in an appropriate character set and with optional details such as their web site or phone number. Not currently implemented.
format
Return a sanely formatted version of the number, complete with IDD code, eg for the Irish number (021) 765-4321 it would return +353 21 7654321.
country
If the number is_international, return the two-letter ISO country code.
NYI
Version restrictions:
- Strictly sppeaking, this kind of duplication of the Number::Phone::UK class is bad. A tidy-up is in order, though it may emerge that a completely new implemantation is better.
- The results are only as accurate as my own investigations into current allocations. User feedback welcome.
- While the names of the nominal owners of mobile prefixes are given, number portability makes this information unreliable.

Number::Encode is a Perl module to encode bit strings into digit strings.

SYNOPSIS

use Number::Encode qw(nonuniform uniform);

Provides a mechanism to convert arbitrary bit-strings into numeric digit strings. The transformation can be uniform or non-uniform depending on the type of distribution of the numeric digits achieved.

The former approach is useful for security-related applications such as calling cards and the such, which require a uniform digit distribution. The algorythm used to generate uniform distributions, while deterministic, is more constly than the non-uniform variant.

This module is distributed under the same terms and warranty as Perl itself.

Test::Number::Delta is a Perl module to compare the difference between numbers against a given tolerance.

SYNOPSIS

# Import test functions
use Test::Number::Delta;

# Equality test with default tolerance
delta_ok( 1e-5, 2e-5, values within 1e-6);

# Inequality test with default tolerance
delta_not_ok( 1e-5, 2e-5, values not within 1e-6);

# Provide specific tolerance
delta_within( 1e-3, 2e-3, 1e-4, values within 1e-4);
delta_not_within( 1e-3, 2e-3, 1e-4, values not within 1e-4);

# Compare arrays or matrices
@a = ( 3.14, 1.41 );
@b = ( 3.15, 1.41 );
delta_ok( @a, @b, compare @a and @b );

# Set a different default tolerance
use Test::Number::Delta within => 1e-5;
delta_ok( 1.1e-5, 2e-5, values within 1e-5); # ok

# Set a relative tolerance
use Test::Number::Delta relative => 1e-3;
delta_ok( 1.01, 1.0099, values within 1.01e-3);

At some point or another, most programmers find they need to compare floating-point numbers for equality. The typical idiom is to test if the absolute value of the difference of the numbers is within a desired tolerance, usually called epsilon. This module provides such a function for use with Test::Harness. Usage is similar to other test functions described in Test::More. Semantically, the delta_within function replaces this kind of construct:

ok ( abs($p - $q) < $epsilon, $p is equal to $q ) or
diag "$p is not equal to $q to within $epsilon";

While theres nothing wrong with that construct, its painful to type it repeatedly in a test script. This module does the same thing with a single function call. The delta_ok function is similar, but either uses a global default value for epsilon or else calculates a relative epsilon on the fly so that epsilon is scaled automatically to the size of the arguments to delta_ok. Both functions are exported automatically.

Because checking floating-point equality is not always reliable, it is not possible to check the equal to boundary of less than or equal to epsilon. Therefore, Test::Number::Delta only compares if the absolute value of the difference is less than epsilon (for equality tests) or greater than epsilon (for inequality tests).

Scalar::Number is a Perl module with numeric aspects of scalars.

SYNOPSIS

use Scalar::Number qw(scalar_num_part);

$num = scalar_num_part($scalar);

use Scalar::Number qw(sclnum_is_natint sclnum_is_float);

if(sclnum_is_natint($value)) { ...
if(sclnum_is_float($value)) { ...

use Scalar::Number qw(sclnum_val_cmp sclnum_id_cmp);

@sorted_nums = sort { sclnum_val_cmp($a, $b) } @floats;
@sorted_nums = sort { sclnum_id_cmp($a, $b) } @floats;

This module is about the numeric part of plain (string) Perl scalars. A scalar has a numeric value, which may be expressed in either the native integer type or the native floating point type. Many values are expressible both ways, in which case the exact representation is insignificant. To fully understand Perl arithmetic it is necessary to know about both of these representations, and the differing behaviours of numbers according to which way they are expressible.
This module provides functions to extract the numeric part of a scalar, classify a number by expressibility, and compare numbers across representations.

TerraJ is a Java port of fractal terrain and simulated solar system generation programs.

The porting has included extensive refactoring, the creation of a documented API to enable reuse of parts in other programs, and extensions such as new Swing user interfaces. Full javadoc for the classes in the project is available.

The TerraJ suite currently contains the following software:

- Fracplanet - Generates fractal planets and terrains with a wide range of user controlled parameters. Has an OpenGL rendering preview using JOGL and can export to POVRay format for rendering.

- Stargen - Creates realistic planetary systems and stars using an accretion simulation. The resulting text and HTML output is template based and configurable.

- Planetary Terrain Generator - A second fractal terrain generation program. This one does not do 3D rendering but can output images using many different map projections.

- Dole Accretion - An older and slightly less complex star system generator included for reference and completeness.

Picture of the Day PHP Script shows daily changing pictures. Each Web page can contain several pictures. Each picture is taken in random order from its own set of directories. An unlimited number of images and directories may be used. Picture of the Day PHP Script doesnt use a database.
Main features:
- Can display several images per page
- Each image is taken from its own set of directories
- Image is randomly taken from directories
- Images are changed daily
- Unlimited number of images
- Unlimited number of directories
- Unlimited number of images per page
- Compatible with Unix and Windows
- Doesnt use database.