Free representation software for linux

Physics::Lorentz::Transformation Perl module contains representation of poincare transformations.

SYNOPSIS

use Physics::Lorentz;
my $rotation = Physics::Lorentz::Transformation->rotation_euler(
$alpha, $beta, $gamma
);
my $vector = Physics::Lorentz::Vector->new([$t, $x, $y, $z]);
my $rotated = $rotation->apply($vector);
# or: $rotated = $rotation * $vector;

...

This class represents a Poincare transformation. That is a proper or improper Lorentz transformation plus a shift by some 4-vector. (x = lamda*x + a)

Yes, the class name might be misleading, but honestly, when most non-physicists talk about Lorentz transformations, they mean Poincare transformations anyway. (Pun intended.)

To sum this up, the set of Poincare transformations contains, among others

Boosts
Rotations
Space Inversions / Parity
Time Inversion
Shifts by a constant vector
Combinations thereof

OVERLOADED INTERFACE

Stringification is overloaded with the stringify method.
Multiplication (*) is overloaded with the merge method for other transformations: $t3 = $t1 * $t2 corresponds to the following application on a vector: t1 * ( t2 * vec ). (I.e. t2 first, then t1) Of course, Poincare transformations do not commute!

The assignment form of multiplication is supported for merging transformations but its use is discouraged unless youre into obfuscation.

Multiplication is also overloaded for application to vectors, but only if the vector is on the right of the transformation: $t * $v is okay, but $v * $t is not.

Restlet is a framework that brings the simplicity and efficiency of the REST architectural style to Java developers.
Restlet project is composed of two parts, a neutral API and a reference implementation (Noelios Restlet Engine). It supports all REST concepts (resource, representation, data, connector, components, etc.) and is suitable for both client and server REST applications.
The server connectors provided are HTTP (via Mortbays Jetty or an adapter Servlet) and the client connectors are HTTP, JDBC, and SMTP (via JavaMail).
Mission
- Bring the simplicity and efficiency of the REST architectural style to Java developers
Restlet API
- Supports all REST concepts (resource, representation, data, connector, components, etc.)
- Suitable for both client and server Web applications
- Maplets support the concept of URIs as UI with advanced pattern matching features
- Chainlets filter calls to implement features such as logging and authentication
- Complete alternative to Servlet API with no external dependency (JAR < 60kb)
- Supports blocking and non-blocking NIO modes
Noelios Restlet Engine (NRE)
- Reference implementation of the Restlet API provided by Noelios Consulting (core JAR < 110kb)
- Server connector provided: HTTP (via Jetty connectors or Servlet connector)
- Client connectors provided: HTTP, JDBC, SMTP (via JavaMail)
- Supports logging (LogChainlet), authentication (GuardChainlet) and cool URIs rewriting (RedirectRestlet)
- Static files serving (DirectoryRestlet) with metadata association based on file extensions
- FreeMarker template representations as an alternative to JSP pages
- Automatic server-side content negotiation based on media type and language

PyReverse is a set of tools for reverse engineering Python code. So far, it features dependency analysis tools, documentation generation, and XMI generation for importation in a UML modeling tool. A special module can be used to generate files readable by Argo UML.
currently PyReverse build a representation of the source tree with:
- docstring for modules, classes, functions
- exceptions raised in functions
- modules attributes, functions, classes
- classs attributes defined in the class scope, inheritance links
- class instances attributes defined in the __init__ method. If possible, get the default value
- functions parameters name and optional default value
- detection of interface/abstract classes and visibility using regular expressions
- detection of links between classes using attributes default value
PyReverse provides modules which use this representation for:
- producing a XMI 1.0 UML 1.3 DOM representation
- creating PGML diagrams definitions according to the project representation, the XMI definition and a XML file which describes briefly the content of the diagrams (see ???). Those diagrams can be readen/edited with Argo UML
- generating UML diagrams readable by VCG (see ???).
- analyzing dependencies (see ???).
- generate skeleton for unit tests, using the unit testing framework for the standard library.

TimeMon gives a graphical representation of where the CPU cycles are going. TimeMon is coarse, but better than nothing.

The best feature is that it runs in an icon on your dock, so that you never lose it.

Originally by Scott Hess, this app has been ported to both GNUstep and Mac OS X.

pytimeago is a human-oriented representation of time deltas, a Python library.

First, I shall define what time delta is. Since Δ generally means “difference”, we take time delta to stand for difference between two events in time. Quite common, however, is to have the current time for the second event. In pytimeago we deal with time deltas from such a perspective.

Quite possibly, you can make use of this library if your application displays some dynamically generated items to the user, and you are looking for a good way to present information on how long ago specific item was created/processed/whatever.

Below is small code snippet demonstrating how simple it is to embed pytimeago:

from pytimeago.english import english
from time import time, sleep

message = queue.getNextMessage()
delta = time() - message.arrived_time
print "Message arrived %s" % english(delta)

Prints, e.g.
Message arrived 15mins ago

As you see, pytimeago is package, and has individual modules for every language supported. As of 2006-08-13 the only supported language is English. However, you can take a look at rather trivial implementation of English engine, write one for your language, and send it to to me (email at the bottom of page).

Every language should come with a set of doctests (I prefer them to casual unit tests), just like the English version does. Dont be too verbose, but check essential cases.

Tk::PerlInheritanceTree is a Perl module that displays a graphical representation of the inheritance tree for a given class-name.

SYNOPSIS

require Tk::PerlInheritanceTree;
...
my $inheritance_tree = $main_window->PerlInheritanceTree()->pack;

$inheritance_tree->classname(Tk::MainWindow);

Tk::PerlInheritanceTree displays a graphical representation of the inheritance tree for a given class(package)-name. The nodes representing classnames have mouseclick bindings to open a Tk::PerlMethodList - widget. Tk::PerlInheritanceTree is a Tk::Frame-derived widget.

PerlInheritanceTree.pm can be run as stand-alone application.

METHODS

Tk::PerlInheritanceTree supports the following methods:

classname(A::Classname)

Set the Classname-Entry to A::Classname and show_classtree.

show_classtree()

Display a tree for the given classname

OPTIONS

Tk::PerlInheritanceTree supports the following options:

-classname

configure(-classname=>A::Classname) same as method classname()

-gridsize

configure(-gridsize=>$size) Set the distance between nodes to $size pixels. Defaults to 100.

-multiple_methodlists

configure(-multiple_methodlists=>bool) Allows multiple instances of PerlMethodList to be opened if set to a true value. Defaults to 0.

Test::Lazy is a quick and easy way to compose and run tests with useful output.

SYNOPSIS

use Test::Lazy qw/check try/;

check(1 => is => 1);
check(0 => isnt => 1);
check(a => like => qr/[a-zA-Z]/);
check(0 => unlike => qr/a-zA-Z]/);
check(1 => > => 0);
check(0 => < => 1);

try(qw/a/ => eq => a);
try(qw/a/ => ne => b);
try(qw/a/ => is => [a]);
try( < stmt >, < cmpr >, < expected >, [ < msg > ] )

Evaluate < stmt> and compare the result to using < cmpr>. Optionally provide a < msg> to display on failure. If < msg> is not given, then one will be automatically made from < stmt>, < cmpr>, and < expected>.
try will also try to guess what representation is best for the result of the statement, whether that be single value, ARRAY, or HASH. Itll do this based on what is returned by the statement, and the type of < expected>. See `perldoc -m Test::Lazy` for more detail.

Note, if < expected> is an ARRAY or HASH, this function will convert it to its JSON representation before comparison.

try("2 + 2" => == => 5);

# This will produce the following output:

# Failed test 2 + 2 == 5
# at __FILE__ line __LINE__.
# got: 4
# expected: 5
check( < got>, < cmpr>, < expected>, [ < msg> ] )

Compare < got> to < expected> using < cmpr>. Optionally provide a < msg> to display on failure. If < msg> is not given, then one will be automatically made from < got>, < cmpr>, and < expected>.

Note, if < got> or < expected> is an ARRAY or HASH, this function will convert them to their JSON representation before comparison.

check([qw/a b/] => is => [qw/a b c/]);

# This will produce the following output:

# Failed test ["a","b"] is ["a","b","c"]
# at __FILE__ line __LINE__.
# got: ["a","b"]
# expected: ["a","b","c"]
template( ... )

Convenience function for creating a Test::Lazy::Template. All arguments are directly passed to Test::Lazy::Template-new>.

See Test::Lazy::Template for more details.

Returns a new Test::Lazy::Template object.

cmpr

< cmpr> can be one of the following:

ok, not_ok, is, isnt, like, unlike,
, =, lt, gt, le, ge, ==, !=, eq, ne,

Japanese Vocabulary is, not surprisingly, an application for studying Japanese vocabulary. It consists of a set of cards, each with 3 pieces of information on them. The 3 pieces of information are the kanji spelling, kana reading, and English (or other language) meaning.
It uses the Leitner system for managing the cards, which means that you see the cards you know well less often than you see the ones that you dont know very well. This allows you to focus on learning those words which you are having trouble with.
The kanji representation of a word (or the kana representation if there is no corresponding kanji for that word) is shown first, and then the user can choose to show the kana and meaning for the word if he/she wants to. The user then decides if he/she got the word right or not, and the card is either moved into a higher deck (where it will be seen less often) or a lower deck (where it will be seen more often.)
Enhancements:
- Several stability enhancements were made.
- The way that cards are chosen was cleaned up.
- The ability to set which piece of data (kanji, kana, or meaning) gets shown by default when a new card is shown was added.