Free genius iq software for linux

Genius project is a calculator program similiar in some aspects to BC, Matlab or Maple. GEL is the name of its extention language (stands for "Genius Extension Language", clever huh?), in fact, a large part of the standard genius functions are written in GEL itself.
Main features:
- Arbitrary precision ints, multiple precision floats, using all the power of gmp.
- Rational numbers, stored as quotient and denominator.
- Complex numbers, stored in cartesian coordinates as usual.
- Automatic typing, no need to declare types of variables.
- Math-like-looking expressions, tries to be as much a what you mean is what Genius understands, up to a limit of course.
- Matrix calculations, with many related functions.
- Modular arithmetic, including inversions and modular arithmetic on matrices.
- A complete programming language. In fact large part of Genius standard library is written in GEL.
- Can output matrices in LaTeX, Troff (eqn) or MathML, this is I think a very cool feature that allows you to copy stuff directly from the Genius console to a document in LaTeX, troff or MathML. I in fact use this even to just enter matrices into LaTeX documents to begin with.
- 2D Function line plots, standard 2D graphs of up to 10 functions at once, with possibility to export to EPS or PNG
- 3D Function surface plots, with possibility to export to EPS or PNG
- GUI IDE where you can edit and run/test your programs
- A plugin interface, not yet really used.

SYNOPSIS

# client connection:
my $c = new Jabber::Connection(
server => jabber.org,
log => 1,
);

# component connection:
# my $c = new Jabber::Connection(
# server => localhost:5700,
# localname => comp.localhost,
# ns => jabber:component:accept,
# log => 1,
# debug => 1,
# );

die "oops: ".$c->lastError unless $c->connect();

$c->register_beat(10, &every_10_seconds);

$c->register_handler(presence,&presence);
$c->register_handler(iq,&handle_iq_conference);
$c->register_handler(iq,&handle_iq_browse);

$c->auth(qmacro,password,myresource); # client auth
# $c->auth(secret); # component auth

$c->send( );

$c->start;
DESCRIPTION ^
The Jabber::Connection package provides basic functions for connecting clients and components to a Jabber server.

GNU Smalltalk is an implementation that closely follows the Smalltalk-80 language as described in the book Smalltalk-80: the Language and its Implementation by Adele Goldberg and David Robson, which will hereinafter be referred to as the Blue Book.
Smalltalk programming language is an object oriented programming language. This means, for one thing, that when programming you are thinking of not only the data that an object contains, but also of the operations available on that object.
The objects data representation capabilities and the operations available on the object are "inseparable"; the set of things that you can do with an object is defined precisely by the set of operations, which Smalltalk calls methods, that are available for that object: each object belongs to a class (a datatype and the set of functions that operate on it) or, better, it is an instance of that class.
You cannot even examine the contents of an object from the outside--to an outsider, the object is a black box that has some state and some operations available, but thats all you know: when you want to perform an operation on an object, you can only send it a message, and the object picks up the method that corresponds to that message.
In the Smalltalk language, everything is an object. This includes not only numbers and all data structures, but even classes, methods, pieces of code within a method (blocks or closures), stack frames (contexts), etc. Even if and while structures are implemented as methods sent to particular objects.
Unlike other Smalltalks (including Smalltalk-80), GNU Smalltalk emphasizes Smalltalks rapid prototyping features rather than the graphical and easy-to-use nature of the programming environment (did you know that the first GUIs ever ran under Smalltalk?).
The availability of a large body of system classes, once you master them, makes it pretty easy to write complex programs which are usually a task for the so called scripting languages. Therefore, even though we have a nice GUI environment including a class browser, the goal of the GNU Smalltalk project is currently to produce a complete system to be used to write your scripts in a clear, aesthetically pleasing, and philosophically appealing programming language.
Installling:
The first thing to do to compile GNU Smalltalk is to configure the program, creating the makefiles and a `gstconf.h, which contains guesses at the systems peculiarities. This configuration is performed automatically by the `configure shell script; to run it, merely type:
./configure
Options that you can pass to configure include --disable-dld, which precludes Smalltalk programs from dynamically linking libraries at run-time.
After youve configured GNU Smalltalk, you can compile the system by typing:
make
Smalltalk should compile and link with no errors. If compiling goes wrong you might want to check the commands used to launch the compiler. For example, be sure to check if your compiler has extensions which, if not enabled, dont make it ANSI compatible. If this is the case, type
make distclean
CFLAGS=needed command-line flags
and retry the configure/make process. In very particular cases, the configure script might miss the presence of a header file or a function on your system. You can patch the `config.cache file created by the configure process. For example, if configure did not find your `unistd.h header file, change the line reading
ac_cv_header_unistd_h=${ac_cv_header_unistd_h=no}
to
ac_cv_header_unistd_h=${ac_cv_header_unistd_h=yes}
and, again, retry the configure/make process.
The last lines of the make output should be like this:
export SMALLTALK_KERNEL=`cd ./kernel; pwd`;
./gst -iQ dummy_file
make[2]: Leaving directory `/home/utente/devel-gst
make[1]: Leaving directory `/home/utente/devel-gst
At this point, you have a working GNU Smalltalk. Congratulations!!!
You will also want to store the Smalltalk sources and create the image file in the proper place (the image file contains a full snapshot of the status of the system). This is done automatically when you do a make install. Specifying --enable-modules as an option to configure will load Smalltalk packages in the automatically installed image. For example
./configure --enable-modules=Blox,TCP
will create an image with the Blox user interface toolkit and the TCP abstraction library built-in.
Main features:
- Memory accessing methods
- Namespaces
- Disk file-IO primitive messages
- The GNU Smalltalk ObjectDumper
- Special kinds of object
- The context unwinding system
- Packages
Note that, in general, GNU Smalltalk is much more powerful than the original Smalltalk-80, as it contains a lot of methods that are common in todays Smalltalk implementation and are present in the ANSI Standard for Smalltalk, but were absent in the Blue Book. Examples include Collections allSatisfy: and anySatisfy: methods and many methods in SystemDictionary (the Smalltalk dictionarys class).
Whats New in 2.95c Development Release:
- This release adds faster startup for gst-load, gst-sunit, and gst-package.
- A source code conversion tool has been installed as gst-convert; it supports Squeak and SIF input, filtering by class or category, and rewrite rules.
- The new packages are DebugTools, Complex, Digest.
- Bugfixes have been made for the .star package system.
- MinGW support and the documentation have been improved.
Whats New in 2.3.5 Stable Release:
- A spurious test failure in the test suite for 64-bit machines and another 64-bit cleanliness problem were fixed.
- Support was added for a rarely used syntax for a block with arguments and no statements.
- Lookahead, filtering, concatenation, and other kinds of manipulation for Streams are now supported in the default image.

Jabber::NodeFactory is a simple XML Node Factory for Jabber.

SYNOPSIS

my $nf = new Jabber::NodeFactory(fromstr => 1);
print $nf->newNode(presence)->toStr;

->

my $tag1 = $nf->newNode(iq);
$tag1->attr(type, get);
my $query = $tag1->insertTag(query, jabber:iq:auth);
$query->insertTag(username)->data(qmacro);
print $tag1->toStr;

->
qmacro

my $tag2 = $nf->newNodeFromStr(" hi ");
$tag2->attr(to,qmacro@jabber.org);
my $msg = $tag2->getTag(body)->data;
print $tag2->toStr, "n";
print $msg;

-> hi
-> hi

Jabber::NodeFactory is a library for creating and manipulating XML nodes. It was created to offer similar functions to the xmlnode library in the Jabber server implementation.
It provides enough functions to create and manipulate XML fragments (nodes) in the Jabber XML stream world. The functions are low level, RISC-style.

Druide DB project is a simple XML file database API in Java to manage an XML database file system without database complexity (no server or client, and stores only strings).
You should try DruideDB if you are doing the following :
- If you are writing a simple application (swing, awt, RCP, ...) that needs to store some kinds of data in the simpliest way,
- If you need a DataBase whitout installing a server or a client on the final users computer,
- If you dont know SQL and your application needs a DataBase but you dont want to deal with all the pool stuff and inherent complexity,
- If you want to try DruideDB,
- If you think Im a genius (well dont tell it, nobody will believe you !)

Class.Jabber.PHP provides a medium-level API to interact with the Jabber network.

Class.Jabber.PHP is a class which you can use to connect to the Jabber network. It allows you to easily connect to a server and interact with it. It supports all packet types (message, iq, and presence), is very flexible, and offers both high-level methods (registration, message sending, etc.) and low-level methods (packet sending, etc.).

The problem with current IM solutions is that they are all proprietary and cannot talk to each other. Jabber seeks to get rid of those barriers by allowing a Jabber client to talk with an AOL user, or an IRC chat room, or any number of other programs.

Class.Jabber.PHP a PHP class that provides a PHP Developer access to the Jabber protocol. Using this OOP class, I provide a clean interface to writing anything from a full client to a simple protocol tester.