Free number bytes human software for linux

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::Interval is a Perl module that can implement a representation of a numeric interval.

SYNOPSIS

use Number::Interval;

$i = new Number::Interval( Min => -4, Max => 20);
$i = new Number::Interval( Min => 0 );

$is = $i->contains( $value );
$status = $i->intersection( $i2 );

print "$i";

Simple class to implement a closed or open interval. Can be used to compare different intervals, determine set membership, calculate intersections and provide default stringification methods.

Intervals can be bound or unbound. If max is less than min the interval is inverted.

Number::Latin is a Perl module that can convert to/from the number system "a,b,...z,aa,ab..."

SYNOPSIS

use Number::Latin;
print join( , map int2latin($_), 1 .. 30), "n";
#
# Prints:
# a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad

Some applications, notably the numbering of points in outlines, use a scheme that starts with the letter "a", goes to "z", and then starts over with "aa" thru "az", then "ba", and so on. (The W3C refers to this numbering system as "lower-latin"/"upper-latin" or "lower alpha"/"upper alpha", in discussions of HTML/CSS options for rendering of list elements (OL/LI).)

This module provides functions that deal with that numbering system, converting between it and integer values.

FUNCTIONS

This module exports four functions, int2latin, int2Latin, int2LATIN, and latin2int:

$latin = int2latin( INTEGER )

This returns the INTEGERth item in the sequence (a .. z, aa, ab, etc). For example, int2latin(1) is "a", int2latin(2) is "b", int2latin(26) is "z", int2latin(30) is "ad", and so for any nonzero integer.

$latin = int2Latin( INTEGER )

This is just like int2latin, except that the return value is has an initial capital. E.g., int2Latin(30) is "Ad".

$latin = int2LATIN( INTEGER )

This is just like int2latin, except that the return value is in all uppercase. E.g., int2LATIN(30) is "AD".

$latin = latin2int( INTEGER )

This converts back from latin number notation (regardless of capitalization!) to an integer value. E.g., latin2int("ad") is 30.

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.

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.

Requirements:

• Nodoka GTK
• Engine

bytetraf project is a small tool for monitoring traffic to and from your machine.

The following information is printed to stdout at a specified time interval: time, interface, bytes received, bytes transfered, and rate.