Free transformation 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.

Iterator::Util Perl package contains essential utilities for the Iterator class.

SYNOPSIS

use Iterator::Util;

# Transform sequences
$iterator = imap { transformation code } $some_other_iterator;

# Filter sequences
$iterator = igrep { condition code } $some_other_iterator;

# Range of values (arithmetic sequence)
$iter = irange ($start, $end, $increment);
$iter = irange ($start, $end);
$iter = irange ($start);

# Iterate over an arbitrary list
$iter = ilist (item, item, ...);
$iter = ilist (@items);

# Iterate over an array, by reference
$iter = iarray (@array);

# Return at most $num items from an iterator
$iter = ihead ($num, $some_other_iterator);
@values = ihead ($num, $some_other_iterator);

# Append multiple iterators into one
$iter = iappend ($it1, $it2, $it3, ...);

# Apply a function to pairs of iterator values
$iter = ipairwise {code} $iter_A, $iter_B;

# Skip the first $num values of an iterator
$iter = iskip ($num, $some_other_iterator);

# Skip values from an iterator until a condition is met
$iter = iskip_until {code} $some_other_iterator;

# Mesh iterators together
$iter = imesh ($iter, $iter, ...);
$iter = izip ($iter, $iter, ...);

# Return each value of an iterator once
$iter = iuniq ($another_iterator);

This module implements many useful functions for creating and manipulating iterator objects.

An "iterator" is an object, represented as a code block that generates the "next value" of a sequence, and generally implemented as a closure. For further information, including a tutorial on using iterator objects, see the Iterator documentation.

HTML::ActiveLink module dynamically activate HTML links based on URL.

SYNOPSIS

use HTML::ActiveLink;

my $al = new HTML::ActiveLink;

print $al->activelink(@html_doc);

I dont know about you, but one of the main problems I have with HTML content is getting images and links to "turn on" depending on the current URL location. That is, I like authoring one set of templates, something like this:

[ < a href="/" >Home< /a > | < a href="/faq/" >FAQ< /a >
| < a href="/about/" >About Us< /a > ]

And then having the appropriate link turned on, so that if Im running inside the /home/ directory, the above turns into this:

[ < font color="red" >Home< /font > | < a href="/faq/" >FAQ< /a >
| < a href="/about/" >About Us< /a > ]

Without having to write a whole bunch of ifs, or writing a bunch of different sets of templates, etc.

This module handles the above process automatically. By default, it will activate any text or images with < a href > tags around them by stripping the link off and changing the appearance of text and names of images. All transformations are fully customizable, allowing you to choose how your active text should look. HTML::ActiveLink can even automatically construct imagemaps depending on your location.
In the simplest case, all you have to do is create a new object by a call to new(), and then call the main activelink() function which takes care of the transformation. To customize what the output HTML looks like, keep reading...

CAD::Drawing::Manipulate::Transform is a Perl module with Matrix methods for CAD::Drawing.

Provides 3D transformation methods (based on traditional matrix algorithms) for Drawing.pm objects.

Coordinate System

All of these methods assume a RIGHT-HANDED coordinate system. If you are using a left-handed coordinate system, you are going to have trouble, trouble, trouble. We arent making video games here!

Spoon is a Java program processor that fully supports Java 5. The project provides a complete and fine-grained Java metamodel where any program element (classes, methods, fields, statements, expressions, etc.) can be accessed both for reading and modification.
It can be used for validation purposes, to ensure that your programs respect some programming conventions or guidelines, or for program transformation, by using a pure Java template engine. It provides an Eclipse plugin (SpoonJDT) that allows for tight integration of Spoon within the Eclipse environment.
With SpoonJDT, a set of validations and transformations packaged as a Spoonlet can occur on the fly, and the reports are well-integrated into the Eclipse JDT.
Enhancements:
- This version includes a lot of bugfixes and new features.
- In particular, Spoon now adjusts the line numbers of the generated bytecode so that they match the original source code.
- So, debugging spooned programs is finally as simple as debugging regular programs.

auto-nng is a software for analysis and classification of data, using artificial neuronal networks. You can feed an amount of datasets consisting of certain input and output parameters into the program, to make it try to find a mathematical correlation between the input and output parameters.
Afterwards the program tries to calculate the output parameters for datasets which only have known input parameters.
auto-nng is free, and can be used and enhanced under the terms of the given license (MIT-style). It was developed under the NetBSD operating system, and runs under Linux (and other similar systems) too.
Enhancements:
- The transformation function for continuous input and output values has been changed to cause a smaller error during defuzzyfication.

Interactive Decompiler project is an interactive decompiler, where the user starts with an almost literal translation of Assembly code in C language, which he progressively decompiles by the successive application of low-level refactorings, ultimately leading to high-level C code.
Main features:
- Import Intel IA32 Assembly code, in the AT&T syntax -- the syntax normally generated by the gcc compiler for the Intel IA32 architecture.
- Visualize and export quasi-C language code.
- Provides a context-sensitive refactoring browser to a set of low-level refactorings.
- Visualize and manipulate the Control Flow Graph (CFG) and the Abstract Syntax Tree (AST).
- For developers:
- It has an extensible data type for program representation.
- It has an easily extensible architecture (new program metadata, new processors, new refactorings, or new visualizations can easily be added).
- It has an embedded language for describing refactorings and other transformation.
- It is possible to modify the refactorings while running the program.
Version restrictions:
- The IA32 instruction set is not yet fully supported, namely the floating-point and SIMD instructions are not yet translated.
- Not all refactoring are implemented, and some are only have a partial implementation.
- The data flow analysis performed in the refactorings focus only on register variables.
- The implementation of several of many necessary the refactorings is still missing due to lack of time.

Tom is a software environment for defining transformations in Java. TOM programming language is an extension of Java designed to manipulate tree structures and XML documents. It is compatible with Java: a Java program is a correct Tom program.
Data are represented using an efficient tree based data-structure. Java built-ins (int, char, String, etc) can be used. Tom provides pattern matching facilities to inspect objects and retrieve values. A powerful strategy language can be used to control transformations.
Enhancements:
- The Eclipse plugin is now available again.
- In the %match construct, the sort of the subject is now optional.
- It is automatically inferred from the patterns when possible.
- Gom generates congruence strategies and offers new functionalities, such as the length of a list.
- A new "!" construct can be used to denote anti-patterns.
- The strategy library has been extended such that strategy expressions can be matched, like any other term.
- A strategy can now take another strategy in its argument.
- Support for Java bytecode analysis and transformation has been added.