Free turing software for linux

Visual Turing Machine project is a program that lets you create Turing machines with a point and click interface instead of using esoteric languages.
You can pack your complex machines into small boxes, and then reuse them as part of a bigger machine. VTM also features an infinite length tape.
Enhancements:
- New features include an n-ary set of symbols, multiple windows (MDI), a huge workspace (10000x10000 pixels) without a memory issue, the ability to edit your own machines, the ability to execute machines n times (where n is undefined), the ability to use expressions (like n+5) to execute machines, the ability to execute machines at desired speeds, statistics to see how many instructions were executed and how much tape was "used", and an easy wasy to translate the program to other languages.

GD::SecurityImage is a security image (captcha) generator.

SYNOPSIS

use GD::SecurityImage;

# Create a normal image
my $image = GD::SecurityImage->new(width => 80,
height => 30,
lines => 10,
gd_font => giant);
$image->random($your_random_str);
$image->create(normal => rect);
my($image_data, $mime_type, $random_number) = $image->out;
or
# use external ttf font
my $image = GD::SecurityImage->new(width => 100,
height => 40,
lines => 10,
font => "/absolute/path/to/your.ttf",
scramble => 1);
$image->random($your_random_str);
$image->create(ttf => default);
$image->particle;
my($image_data, $mime_type, $random_number) = $image->out;

or you can just say (most of the public methods can be chained)

my($image, $type, $rnd) = GD::SecurityImage->new->random->create->particle->out;

to create a security image with the default settings. But that may not be useful. If you require the module, you must import it:

require GD::SecurityImage;
GD::SecurityImage->import;

The module also supports Image::Magick, but the default interface uses the GD module. To enable Image::Magick support, you must call the module with the use_magick option:

use GD::SecurityImage use_magick => 1;

If you require the module, you must import it:

require GD::SecurityImage;
GD::SecurityImage->import(use_magick => 1);

The module does not export anything actually. But import loads the necessary sub modules. If you don t import, the required modules will not be loaded and probably, youll die().

The (so called) "Security Images" are so popular. Most internet software use these in their registration screens to block robot programs (which may register tons of fake member accounts). Security images are basicaly, graphical CAPTCHAs (Completely Automated Public Turing Test to Tell Computers and Humans Apart). This module gives you a basic interface to create such an image. The final output is the actual graphic data, the mime type of the graphic and the created random string. The module also has some "styles" that are used to create the background (or foreground) of the image.

If you are an Authen::Captcha user, see GD::SecurityImage::AC for migration from Authen::Captcha to GD::SecurityImage.

This module is just an image generator. Not a captcha handler. The validation of the generated graphic is left to your programming taste.

Argh! is an esoteric programming language in the spirit of Befunge, Brainfuck, and friends. Argh! project is a nice and simple language with two dimensional code-flow, a combined code/data array, an infinite stack, regular characters for all instructions, no strange braces or symbols, no unnecessary arithmetic operators (add and sub are all you need), and countless other features it doesnt have.

The distribution includes interpreters for Argh! and Aargh! (an extended Argh! that is most likely Turing complete), the official specification, editing modes for emacs and vim, and lots of examples.

Installation

To build the interpreters simply type make. This will produce two binaries: `argh the Argh! interpreter and `aargh the extended Argh! (Aargh!) interpreter. For instructions on installing the Emacs Argh! mode please look at the comments in `argh-mode.el.

Usage

Usage is simple, just call the interpreter with the filename of the Argh!-program as first argument:

$ argh ./examples/hello.agh

If the interpreter gets called with no argument, it reads the Argh!-program from stdin.

You can even put "#!/path/to/argh-interpreter" in the first line of your code and make the Argh! program executable. (At least on systems, which understand #!-magic).

Statistics::Smoothing::SGT is a Simple Good-Turing (SGT) smoothing implementation.

SYNOPSIS

Basic Usage

use Statistics::Smoothing::SGT
my $sgt = new Statistics::Smoothing::SGT($frequencyClasses, $total);
$sgt->calculateValues();
$probabilities = $sgt->getProbabilities();
$newFrequencies = $sgt->getNewFrequencies();
$nBar = $sgt->getNBar();

A highly responsive Turing machine simulator written in Tcl/Tk. Contains many examples (unary and binary addition, subtraction, multiplication, a 5-state busy beaver, 2 string parsing examples, divisibility test, primality test), a theoretical introduction to Turing machines, a proof of the undecidability of the halting problem and pointers to further literature.

Ghost Diagrams is a project that takes sets of tiles and tries to find patterns into which they may be formed. The patterns it finds when given randomly chosen tiles are often surprising.

It turns out that tiling patterns are a form of computation of equal power to Turing machines, lambda calculus, and cellular automata. For example, here is a tileset implementing "Rule 110", a cellular automaton known to be capable of universal computation.

Considerations similar to the halting problem and Godels theorem apply. There is no upper limit to their capacity to surprise us. Furthermore, tiles have an intuitive quality that other forms of computation lack. You can see how they fit together.

An organism is more than the sum of its organs. When the organs are fitted together, the organism becomes something more. This surprising something more we call "spirit" or "ghost". Ghost Diagrams finds the ghosts implicit in simple sets of tiles.

DL/SQL is declarative, turing-complete programming language based on top of SQL database. The main idea is to store both program and data in one SQL table and make all the computations in it.

The current version of interpreter written in PHP contains quasi-lazy evaluation and simple caching.

The syntax was inspired by LISP and bash. Sounds strange? For example,

(* (+ 2 4 (#FACT 4)) 3)


means (2 + 4 + fact(4)) * 3 where fact is user-defined function for factorial.

As youve probably noticed, DL/SQL has got prefix (polish) notation with compulsory bracketing. That means, in front any name of function there must be opening bracket and after last parameter of a function there must be closing bracket. With this rule its really easy to implement variable-length argument lists.

For real deployment its necessary to change the core according to your needs - some special constructions are always necessary. Fortunatelly the core is flexible and easily extendable. Right now DL/SQL uses MySQL as its backend. Therere only several calls to DB, changing them is work for few minutes so porting DL/SQL to lets say PostgreSQL is piece of cake.

Therere only two API calls:

rpn_init()

clears all the cached values (actually sets the counted bit to false).

rpn_eval($expression)

evaluates entered DL/SQL expression. For using DL/SQL interpreter its necessary to include file rpnparser.phtml in your project. For easy implementation I also advise you to include file include/setup.phtml which contains all the necassary stuff for connecting to database and setting the directories. Without this file, youll have to do all the things yourself!