Free bin to hex calc software for linux

Math::BigInt::Calc is a pure Perl module to support Math::BigInt.

SYNOPSIS

Provides support for big integer calculations. Not intended to be used by other modules. Other modules which sport the same functions can also be used to support Math::BigInt, like Math::BigInt::GMP or Math::BigInt::Pari.

In order to allow for multiple big integer libraries, Math::BigInt was rewritten to use library modules for core math routines. Any module which follows the same API as this can be used instead by using the following:

use Math::BigInt lib => libname;
libname is either the long name (Math::BigInt::Pari), or only the short version like Pari.

METHODS

The following functions MUST be defined in order to support the use by Math::BigInt v1.70 or later:

api_version() return API version, 1 for v1.70, 2 for v1.83
_new(string) return ref to new object from ref to decimal string
_zero() return a new object with value 0
_one() return a new object with value 1
_two() return a new object with value 2
_ten() return a new object with value 10

_str(obj) return ref to a string representing the object
_num(obj) returns a Perl integer/floating point number
NOTE: because of Perl numeric notation defaults,
the _numified obj may lose accuracy due to
machine-dependent floating point size limitations

_add(obj,obj) Simple addition of two objects
_mul(obj,obj) Multiplication of two objects
_div(obj,obj) Division of the 1st object by the 2nd
In list context, returns (result,remainder).
NOTE: this is integer math, so no
fractional part will be returned.
The second operand will be not be 0, so no need to
check for that.
_sub(obj,obj) Simple subtraction of 1 object from another
a third, optional parameter indicates that the params
are swapped. In this case, the first param needs to
be preserved, while you can destroy the second.
sub (x,y,1) => return x - y and keep x intact!
_dec(obj) decrement object by one (input is guaranteed to be > 0)
_inc(obj) increment object by one


_acmp(obj,obj) operator for objects (return -1, 0 or 1)

_len(obj) returns count of the decimal digits of the object
_digit(obj,n) returns the nth decimal digit of object

_is_one(obj) return true if argument is 1
_is_two(obj) return true if argument is 2
_is_ten(obj) return true if argument is 10
_is_zero(obj) return true if argument is 0
_is_even(obj) return true if argument is even (0,2,4,6..)
_is_odd(obj) return true if argument is odd (1,3,5,7..)

_copy return a ref to a true copy of the object

_check(obj) check whether internal representation is still intact
return 0 for ok, otherwise error message as string

_from_hex(str) return new object from a hexadecimal string
_from_bin(str) return new object from a binary string
_from_oct(str) return new object from an octal string

_as_hex(str) return string containing the value as
unsigned hex string, with the 0x prepended.
Leading zeros must be stripped.
_as_bin(str) Like as_hex, only as binary string containing only
zeros and ones. Leading zeros must be stripped and a
0b must be prepended.

_rsft(obj,N,B) shift object in base B by N digits right
_lsft(obj,N,B) shift object in base B by N digits left

_xor(obj1,obj2) XOR (bit-wise) object 1 with object 2
Note: XOR, AND and OR pad with zeros if size mismatches
_and(obj1,obj2) AND (bit-wise) object 1 with object 2
_or(obj1,obj2) OR (bit-wise) object 1 with object 2

_mod(obj1,obj2) Return remainder of div of the 1st by the 2nd object
_sqrt(obj) return the square root of object (truncated to int)
_root(obj) return the nth (n >= 3) root of obj (truncated to int)
_fac(obj) return factorial of object 1 (1*2*3*4..)
_pow(obj1,obj2) return object 1 to the power of object 2
return undef for NaN
_zeros(obj) return number of trailing decimal zeros
_modinv return inverse modulus
_modpow return modulus of power ($x ** $y) % $z
_log_int(X,N) calculate integer log() of X in base N
X >= 0, N >= 0 (return undef for NaN)
returns (RESULT, EXACT) where EXACT is:
1 : result is exactly RESULT
0 : result was truncated to RESULT
undef : unknown whether result is exactly RESULT
_gcd(obj,obj) return Greatest Common Divisor of two objects
The following functions are REQUIRED for an api_version of 2 or greater:
_1ex($x) create the number 1Ex where x >= 0
_alen(obj) returns approximate count of the decimal digits of the
object. This estimate MUST always be greater or equal
to what _len() returns.
_nok(n,k) calculate n over k (binomial coefficient)

The following functions are optional, and can be defined if the underlying lib has a fast way to do them. If undefined, Math::BigInt will use pure Perl (hence slow) fallback routines to emulate these:

_signed_or
_signed_and
_signed_xor

Input strings come in as unsigned but with prefix (i.e. as 123, 0xabc or 0b1101).

So the library needs only to deal with unsigned big integers. Testing of input parameter validity is done by the caller, so you need not worry about underflow (f.i. in _sub(), _dec()) nor about division by zero or similar cases.

The first parameter can be modified, that includes the possibility that you return a reference to a completely different object instead. Although keeping the reference and just changing its contents is preferred over creating and returning a different reference.

Return values are always references to objects, strings, or true/false for comparison routines.

Convert::BinHex can extract data from Macintosh BinHex files.

ALPHA WARNING: this code is currently in its Alpha release. Things may change drastically until the interface is hammered out: if you have suggestions or objections, please speak up now!

SYNOPSIS

Simple functions:

use Convert::BinHex qw(binhex_crc macbinary_crc);

# Compute HQX7-style CRC for data, pumping in old CRC if desired:
$crc = binhex_crc($data, $crc);

# Compute the MacBinary-II-style CRC for the data:
$crc = macbinary_crc($data, $crc);

Hex to bin, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Hex2Bin") which keeps internal conversion state:
# Create and use a "translator" object:
my $H2B = Convert::BinHex->hex2bin; # get a converter object
while (< STDIN >) {
print $STDOUT $H2B->next($_); # convert some more input
}
print $STDOUT $H2B->done; # no more input: finish up

Hex to bin, OO interface. The following operations must be done in the order shown!
# Read data in piecemeal:
$HQX = Convert::BinHex->open(FH=>*STDIN) || die "open: $!";
$HQX->read_header; # read header info
@data = $HQX->read_data; # read in all the data
@rsrc = $HQX->read_resource; # read in all the resource

Bin to hex, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Bin2Hex") which keeps internal conversion state:
# Create and use a "translator" object:
my $B2H = Convert::BinHex->bin2hex; # get a converter object
while (< STDIN >) {
print $STDOUT $B2H->next($_); # convert some more input
}
print $STDOUT $B2H->done; # no more input: finish up

Bin to hex, file interface. Yes, you can convert to BinHex as well as from it!
# Create new, empty object:
my $HQX = Convert::BinHex->new;

# Set header attributes:
$HQX->filename("logo.gif");
$HQX->type("GIFA");
$HQX->creator("CNVS");

# Give it the data and resource forks (either can be absent):
$HQX->data(Path => "/path/to/data"); # here, data is on disk
$HQX->resource(Data => $resourcefork); # here, resource is in core

# Output as a BinHex stream, complete with leading comment:
$HQX->encode(*STDOUT);

PLANNED!!!! Bin to hex, "CAP" interface. Thanks to Ken Lunde for suggesting this.
# Create new, empty object from CAP tree:
my $HQX = Convert::BinHex->from_cap("/path/to/root/file");
$HQX->encode(*STDOUT);

BinHex is a format used by Macintosh for transporting Mac files safely through electronic mail, as short-lined, 7-bit, semi-compressed data streams. Ths module provides a means of converting those data streams back into into binary data.

NetCalendar is a network capable and mostly UNIX /usr/bin/calendar database compatible Calendar application programmed in Java.

NetCalendars initial motivaion was a programming project at the Aachen University of Applied Sciences for the object oriented programming class. But it became much more than just that!

Fung-Calc project is an easy to use 2D and 3D graphing calculator written using the Qt libraries.
It supports various graphing modes in both 2D and 3D.
It combines all the features of a full-blown mathematical analysis package with ease of use.
Installing
To compile with all features enabled as is the default, type
$ ./configure
After this has completed, if you have a version of Qt before 3.1 or get errors while compiling the UI files with messages like "Undefined reference languageChanged()", type:
$ make clean
to remake all UI files. Then continue as normal and type
$ make
and then install as root with
$ make install
Enhancements:
- Some issues have been brought to my attention concerning the latest release version 1.3.2, and I have tried to correct these issues as quickly as possible.
- This release fixes a compile error for some compilers and also fixes some menu bar issues for versions of Qt < 3.1.
- Also, the documentation handbook is not compiled if disable-kde-app is given to configure, since KDE tools are required to build it.

hexdump produces a CP/M-like format by default, and can handle EBCDIC. It is internationalized, and has many formatting functions.
This hex dumper was born because
a) od octal format is appallingly ugly
b) od -x aint much better
c) I needed to dump EBCDIC files from SNA sessions
d) I needed to dump single blocks of files offset into the file.
If any of these describes your universe, youll like it too. The format resembles a CP/M or MS/DOS DEBUG dump screen. There is nothing UNIX-specific in the source, it should work OK under any C with a stdio.h library.
Enhancements:
- Source RPMs no longer depend on --define myversion

BattleTech THUD is a Java client designed to connect to Battletech MUXes and display combat data in a easy-to-read tactical display. BattleTech THUD client displays a tactical map, contacts list, armor status and more.
Main features:
- ANSI color support
- An impressive tactical map display: see screenshots
- All enemy and friendly contacts with headings
- Unique icons for each movement type
- Current heading and desired heading indicators
- Weapons arc indicators
- An overall armor percentage display
- A heat indicator
- Display of hex numbers if desired
- Varying colors of hexes based on height
- A separate contacts window
- Customizable colors and font sizes
- Much more...

Calc is arbitrary precision arithmetic system that uses a C-like language. Calc is useful as a calculator, an algorithm prototype, and as a mathematical research tool.
More importantly, calc provides a machine-independent means of computation. Calc comes with a rich set of builtin mathematical and programmatic functions.
For example, the following line can be input:
3 * (4 + 1)
and the calculator will print:
15
Calc as the usual collection of arithmetic operators +, -, /, * as well as ^ exponentiation), % (modulus) and // (integer divide). For example:
3 * 19^43 - 1
will produce:
29075426613099201338473141505176993450849249622191102976
Notice that calc values can be very large. For example:
2^23209-1
will print:
402874115778988778181873329071 ... many digits ... 3779264511
The special . symbol (called dot), represents the result of the last command expression, if any. This is of great use when a series of partial results are calculated, or when the output mode is changed and the last result needs to be redisplayed. For example, the above result can be modified by typing:
. % (2^127-1)
and the calculator will print:
39614081257132168796771975167
For more complex calculations, variables can be used to save the intermediate results. For example, the result of adding 7 to the previous result can be saved by typing:
curds = 15
whey = 7 + 2*curds
Functions can be used in expressions. There are a great number of pre-defined functions. For example, the following will calculate the factorial of the value of old:
fact(whey)
and the calculator prints:
13763753091226345046315979581580902400000000
The calculator also knows about complex numbers, so that typing:
(2+3i) * (4-3i)
cos(.)
will print:
17+6i
-55.50474777265624667147+193.9265235748927986537i
The calculator can calculate transcendental functions, and accept and display numbers in real or exponential format. For example, typing:
config("display", 70)
epsilon(1e-70)
sin(1)
prints:
0.8414709848078965066525023216302989996225630607983710656727517099919104
Calc can output values in terms of fractions, octal or hexadecimal. For example:
config("mode", "fraction"),
(17/19)^23
base(16),
(19/17)^29
will print:
19967568900859523802559065713/257829627945307727248226067259
0x9201e65bdbb801eaf403f657efcf863/0x5cd2e2a01291ffd73bee6aa7dcf7d1
All numbers are represented as fractions with arbitrarily large numerators and denominators which are always reduced to lowest terms. Real or exponential format numbers can be input and are converted to the equivalent fraction. Hex, binary, or octal numbers can be input by using numbers with leading 0x, 0b or 0 characters.
Complex numbers can be input using a trailing i, as in 2+3i. Strings and characters are input by using single or double quotes.
Commands are statements in a C-like language, where each input line is treated as the body of a procedure. Thus the command line can contain variable declarations, expressions, labels, conditional tests, and loops. Assignments to any variable name will automatically define that name as a global variable.
The other important thing to know is that all non-assignment expressions which are evaluated are automatically printed. Thus, you can evaluate an expressions value by simply typing it in.
Many useful built-in mathematical functions are available. Use the:
help builtin
command to list them.
You can also define your own functions by using the define keyword, followed by a function declaration very similar to C.
define f2(n)
{
local ans;
ans = 1;
while (n > 1)
ans *= (n -= 2);
return ans;
}
Thus the input:
f2(79)
will produce;
1009847364737869270905302433221592504062302663202724609375
Functions which only need to return a simple expression can be defined using an equals sign, as in the example:
define sc(a,b) = a^3 + b^3
Thus the input:
sc(31, 61)
will produce;
256772
Variables in functions can be defined as either global, local, or static. Global variables are common to all functions and the command line, whereas local variables are unique to each function level, and are destroyed when the function returns.
Static variables are scoped within single input files, or within functions, and are never destroyed. Variables are not typed at definition time, but dynamically change as they are used.
Enhancements:
- Documentation was written for the # operator, comments, and cscripts.
- Multi-line statement issues were documented.
- Builtins related to user, system, and clock time were added.
- The runtime() builtin output was changed.