Free lmarbles 1.0.7 software for linux

LMarbles is an Atomix clone with a slight change in concept. Instead of assembling molecules you create figures out of marbles. Nevertheless, the basic game play is the same: If a marble starts to move it will not stop until it hits a wall or another marble.

To make it more interesting there are obstacles like one-way streets, crumbling walls and portals.

As Marbles is meant as a puzzle game you play against a move limit and not a time limit. This way you have as much time as you need to think.

Libeval provides simple means of evaluating simple arithmetic expressions involving literal numeric values, variables and functions using the addition (+), subtraction (-), multiplication (*), division (/), modulo division (), exponentiation (^), sign (+-), percentag (%) and grouping (()) operators.
Libeval provides a means of setting and interrogating variables, defining functions and converting error codes into human readable strings. A number of predefined functions are included with libeval that wrap the existing standard C library math functions.
You can evaluate an expression by calling the eval() function. eval() takes two parameters, the expression to evaluate (as a simple C string) and a reference to a double precision float in which to put the result. If eval() encounters an error it returns a non-zero value, otherwise, if everything went well, it returns zero.
The error code returned by eval() can be converted into a human readable string by the eval_error() function. eval_error() takes one parameter, the error code returned by eval(),and returns a constant string describing the error.
Variables can be manipulated with the eval_set_var() and eval_get_var() functions.
eval_set_var() sets the named variable to the specified double precision value. eval_set_var() takes two parameters, the name of the variable to set as a simple C string, and the double precision float value to set the variable to. it returns 0 (zero) on success, non-zero on failure.
eval_get_var() gets the value of the named variable. eval_get_var() takes two parameters, the name of the variable as a simple C string and a reference to a double precision float in which to store the variables value. it returns 0 (zero) on success, non-zero on failure.
Functions can be defined with the eval_def_fn() function, which takes the name of the function as a simple C string, a pointer to a C function implementing the function, a pointer to a block of custom storage for use by the function and the number of arguments taken by the function. The prototype for the implementation function is:
int fn(int args, double *arg, double *rv, void *data);
The first two parameters (args and arg) are similar to the standard parameters to the main() function in C, the args parameter indicates how many elements are the argument list, and arg is the argument list itself. The third parameter (rv) is the return value from the function. The last parameter (data) is the custome storage block passed in when the function was defined.
If you specify a positive value (including zero) as the number of arguments for a function, libeval will only all the function to be called with exactly that number of parameters. If you specify a -1 (negative one) for the number of arguments, the function can be called with any number of parameters.
The following functions are predefined:
abs(x) absolute value of x
int(x) integer part of x
round(x) round x to nearest integer
trunc(x) truncate x (same as int(x))
floor(x) round x to nearest lesser integer
ceil(x) round x to nearest greater integer
sin(x) sine of x (radians)
cos(x) cosine of x (radians)
tan(x) tangent of x (radians)
asin(x) arc sine of x (radians)
acos(x) arc cosine of x (radians)
atan(x) arc tangent of x (radians)
sinh(x) hyperbolic sine of x (radians)
cosh(x) hyperbolic cosine of x (radians)
tanh(x) hyperbolic tangent of x (radians)
asinh(x) hyperbolic arc sine of x (radians)
acosh(x) hyperbolic arc cosine of x (radians)
atanh(x) hyperbolic arc tangent of x (radians)
deg(x) convert radians to degrees
rad(x) convert degrees to radians
ln(x) natural logarithm of x
log(x) base 10 logarithm of x
sqrt(x) square root of x
exp(x) e to x power
rand() random number between 0.0 and 1.0
fact(x) factorial of x (or gamma(x) if x is non-integer)
sum(...) sum of the arguments
min(...) minimum value in arguments
max(...) maximum value in arguments
avg(...) average of arguments
med(...) median of arguments
var(...) variance of arguments
std(...) standard deviation of arguments
Finally, you can get a set of bookkeepping information about the eval_expr libray with the eval_info() function. eval_info() takes nine parmaeters: three references to integer values for the version, revision and build numbers of the current eval_expr library, and three pairs of buffer address and buffer size limit for authors name, copyright info and license info.
You can use libeval by including the libeval header in your program source
#include
and then by linking your program against the libeval library
gcc -o myprog myprog.c -leval
Enhancements:
- A bug in the var() function and version string construction were fixed.

JZlib is a re-implementation of zlib in pure Java. The first and final aim for hacking this was to add packet compression support to pure Java SSH systems.
Main features:
- Needless to say, JZlib can inflate data, which is deflated by zlib and JZlib can generate deflated data, which is acceptable and is inflated by zlib.
- JZlib supports all compression level and all flushing mode in zlib.
- JZlib does not support gzip file handling supports.
- The performance has not been estimated yet, but it will not be so bad in deflating/inflating data stream on the low bandwidth network.
- JZlib is licensed under BSD style license
- Any invention has not been done in developing JZlib. So, if zlib is patent free, JZlib is also not covered by any patents.
Enhancements:
- change: memory and performance optimizations in the inflate operation.
- Many thanks to Paul Wakefield at platx.org(http://www.platx.org), who suggested above improvements.
- change: added the nowrap argument to Z{Input,Output}?Stream.

EasyTool is the library of Perl Functions in Common Usage.

SYNOPSIS

use EasyTool;

if(defined(&EasyTool::foo)){
print "lib is included";
}else{
print "lib is not included";
}

print EasyTool::is_int(2147483647); #true
print EasyTool::is_int(-2147483648); #true
print EasyTool::is_int(2147483648); #false

print EasyTool::is_id(4294967295); #true
print EasyTool::is_id(4294967296); #false

print EasyTool::is_email("xxx.abc@test.com"); #true

print EasyTool::trim(" t testn "); #test

print EasyTool::in(a, {a => 1, b => 2}); #true
print EasyTool::in(undef, 1, undef); #true

print EasyTool::ifnull(undef, 1); #1

print EasyTool::read_file("file.in");
print EasyTool::write_file("file.out", "string");
print EasyTool::append_file("file.out", "string");
print EasyTool::delete_file("file.out");

$ra_array = EasyTool::csv_2_array("a.csv");
print EasyTool::array_2_csv("a.csv", $ra_array);

print EasyTool::md5_hex("test"); #098f6bcd4621d373cade4e832627b4f6

print EasyTool::crc32("test"); #3632233996

$str = &EasyTool::encode_hex("hello");
print EasyTool::decode_hex($str); #hello

$str = &EasyTool::encode_base64("hello");
print EasyTool::decode_base64($str); #hello

$str = &EasyTool::url_encode(@^);
print EasyTool::url_decode($str); #@^

$str = &EasyTool::html_encode(";<<less