Free gap software for linux

GGAP project is a GTK+ frontend for GAP computer algebra system.
Main features:
- GAP-friendly text editor.
- GAP-friendly terminal emulator.
- Shared package which enables creating gui in GAP, somewhat similar to XGAP.

Statistics::Gap Perl module is an adaptation of the Gap Statistic.

SYNOPSIS

use Statistics::Gap;
$predictedk = &gap("prefix", "vec", INPUTMATRIX, "rbr", "h2", 30, 10, rep, 90, 4);

OR

use Statistics::Gap;
$predictedk = &gap("prefix", "vec", INPUTMATRIX, "rbr", "h2", 30, 10, rep, 90, 4, 7);

INPUTS

1. Prefix: The string that should be used to as a prefix while naming the intermediate files and the .dat files (plot files).
2. Space: Specifies the space in which the clustering should be performed. Valid parameter values: vec - vector space sim - similarity space
3. InputMatrix: Path to input matrix file. (More details about the input file-format below.)
4. ClusteringMethod: Specifies the clustering method to be used. (Learn more about this at: http://glaros.dtc.umn.edu/gkhome/cluto/cluto/overview)
Valid parameter values:
rb - Repeated Bisections
rbr - Repeated Bisections for by k-way refinement
direct - Direct k-way clustering
agglo - Agglomerative clustering
bagglo - Partitional biased Agglomerative clustering
NOTE: bagglo can be used only if space=vec
5. Crfun: Specifies the criterion function to be used for finding clustering solutions. (Learn more about this at: http://glaros.dtc.umn.edu/gkhome/cluto/cluto/overview)
Valid parameter values:
i1 - I1 Criterion function
i2 - I2 Criterion function
e1 - E1 Criterion function
h1 - H1 Criterion function
h2 - H2 Criterion function
6. K: This is an approximate upper bound for the number of clusters that may be present in the dataset.
7. B: The number of replicates/references to be generated.
8. TypeRef: Specifies whether to generate B replicates from a reference or to generate B references.
Valid parameter values:
rep - replicates
ref - references
9. Percentage: Specifies the percentage confidence to be reported in the log file. Since Statistics::Gap uses parametric bootstrap method for reference distribution generation, it is critical to understand the interval around the sample mean that could contain the population ("true") mean and with what certainty.
10. Precision: Specifies the precision to be used while generating the reference distribution.
11. Seed: The seed to be used with the random number generator. (This is an optional parameter. By default no seed is set.)

GladePyC is a Python code generator tool, from Glade XML save file, to the low-level part of "PyGtk", the Python - Gtk+ binding. Glade is a GUI builder for the Gtk+ GUI toolkit. PyGtk is the gateway between Python and Gtk+.
Why:
Those who know surely have already made the remark: "But why on earth doesnt he use libglade ?"... Here is what I think of it:
- There is roughly two approaches to working with Python and Glade: a run-time one (libglade) where UI descriptions are loaded during execution, and a compile-time one where UI descriptions are statically compiled into target language source code. Both have strong and weak points (I wont debate here), but for python the code generation option was not enough developped since GLC (advertised on Glades links page) is not object oriented. GladePyC aims to fill this little gap.
- The python binding of libglade loads the GUI using the high-level, object-oriented layer (gtk.py), not the basic layer; This means at least 3 objects per widget are present in memory (Gtk+, libglades XML and gtk.pys) which I find is a waste of memory for things we dont need once loaded (and by adding layers it may slow down things notably).
- If you need dynamic interfaces, where multiple instances of the same window class are created, you have to reload the UI description (analyzing XML and all) because libglade doesnt know how to make a new actual widget tree from the in-memory, XML represented, UI description. Additionally you have to reload from a file: loading from a string in memory is unusable because a function is missing in the Python binding.
- It requires an additional library ! Ok its not a pain to install it, but its always better if you dont need it; Actually I want OpenVMS as a potential target, and it is lacking libglade.
Additionally gladepyc has some features I wanted, that are not found in libglade nor GLC:
- Object-orientedness (1): windows and widget subtrees have their building code generated as classes, so that multiple, independant instances of them can be created.
- Individual widgets are accessible by their name as attributes of instanciated objects.
- Object-orientedness (2): signal connections are made to methods of so-called "controller" objects (Java calls them "listeners"), not functions. There is support for connecting a whole set of signals at once, based on the name of callbacks, which presence is checked as methods of the controller. This allows each window (or subpart) to be managed by a separate controller without having to pass additional arguments to callbacks.
- Object-orientedness (3): data classes can be made, to serve as quick access method to data stored at runtime in widget instances. Each value is accessed as an attribute of the instanciated object, through an attribute with the same name as the corresponding widget.
- and there is a lot more: see README. I will write documentation when things have matured.
- As you can see, there are some benefits to static code generation approach, which are difficult to achieve with a run-time library (though in our case it would be able to, since Python is interpreted and can dynamically define new classes and functions)

at-spi is the Gnome Accessibility Project.

Building the documentation:

Pre-built versions of the HTML documentation are available at http://developer.gnome.org/projects/gap/tech-docs/at-spi-docs/book1.html. However the documentation in the docs directory is the most up-to-date. Building the docs requires docbook and jade, see the gtk-doc package (from Gnome CVS) for more information.

Use of the AT-SPI:

Accessible applications will register with this registry service (via bonobo-activation) and adaptive/assistive technologies will register with the service as well, to indicate their interest in receiving UI events. ATs can also use the registrys services programmatically to query accessible applications.

Running the test programs:

At the moment the only clients and are two test at clients (at and simple-at). There is also a test app (app) in the tests subdirectory.

If you have a working ORBit2/bonobo-activation installation you can run the tests after adding the registryd directory to the bonobo-activation directory list with bonobo-activation-sysconf, or by installing Accessibility_Registry.server in your bonobo-activation servers directory.

You can then run ./at and ./app from the test directory, to see app register as an application, and at as a listening client. Bonobo should take care of the job of bootstrapping the registry daemon (registryd) for you. These test programs use the bonobo/CORBA C bindings directly.

Chart::EPS_graph creates line graphs in PostScript as *.eps format.

SYNOPSIS

# Create anew a 600 x 600 points (not pixels!) EPS file
my $eps = Chart::EPS_graph->new(600, 600);

# Choose minimum required display info
$eps->set(
label_top => Graph Main Title,
label_y1 => Y1 Axis Measure (Units),
label_y2 => Y2 Axis Measure (Units),
label_x => X Axis Measure (Units),
);

# Choose 6 of 13 named chans, 4 at left, 2 at right
$eps->set(
names => @all_13_name_strings,
data => @all_13_data_arefs,
y1 => [7, 8, 10, 11],
y2 => [9, 12],
);


# Choose optional graph features
$eps->set(
label_y1_2 => Extra Y1 Axis Info,
label_y2_2 => Extra Y2 Axis Info,
label_x_2 => Extra X Axis Info,

# Any common browser color no matter how hideous.
bg_color => DarkOliveGreen,
fg_color => HotPink,
web_colors => [Crimson, Lime, Indigo, Gold, Snow, Aqua],

# Any known I font no matter how illegible
font_name => ZapfChancery-MediumItalic,
font_size => 18,

# See POD about this one. But in brief:
# If set to "1" channel innumeration gaps will be closed.
# If set to "0" (the default) they will be left as they are.
close_gap => 0,

# If the 0th channel is not for the X axis (the default) then the
# data point count is used as the X axis, which you may scale.
# So if X were Time in seconds, with no 0th channel having acutally
# recorded it, but each data point were known to be 0.5 seconds...
$self->{x_is_zeroth} = 0; # Boolean, so 1 or 0.
$self->{x_scale} = 2; # Have 10th datapoint show as 20, etc.
);

# Write output as EPS
$eps->write_eps( cwd() . /whatever.eps ); # Write to a file.

# View, convert or edit the EPS output
$eps->display(); # Display in viewer (autodetects gv or gsview.exe).
$eps->display(GS); # Convert to PNG via Ghostscript.
$eps->display(GIMP); # Open for editng in The GIMP.

The GIMP is the GNU Image Manipulation Program. It is a freely distributed piece of software for such tasks as photo retouching, image composition and image authoring. The Gimp works on many operating systems, in many languages.
GIMP is an acronym for GNU Image Manipulation Program. It is a freely distributed program for such tasks as photo retouching, image composition and image authoring.
It has many capabilities. It can be used as a simple paint program, an expert quality photo retouching program, an online batch processing system, a mass production image renderer, an image format converter, etc.
GIMP is expandable and extensible. It is designed to be augmented with plug-ins and extensions to do just about anything. The advanced scripting interface allows everything from the simplest task to the most complex image manipulation procedures to be easily scripted.
GIMP is written and developed under X11 on UNIX platforms.
Main features:
Painting
- Full suite of painting tools including Brush, Pencil, Airbrush, Clone, etc.
- Sub-pixel sampling for all paint tools for high quality anti-aliasing
- Extremely powerful gradient editor and blend tool
- Supports custom brushes and patterns
System
- Tile based memory management so image size is limited only by available disk space
- Virtually unlimited number of images open at one time
Advanced Manipulation
- Full alpha channel support
- Layers and channels
- Multiple Undo/Redo (limited only by diskspace)
- Editable text layers
- Transformation tools including rotate, scale, shear and flip
- Selection tools including rectangle, ellipse, free, fuzzy and intelligent
- Advanced path tool doing bezier and polygonal selections.
- Transformable paths, transformable selections.
- Quickmask to paint a selection.
Extensible
- A Procedural Database for calling internal GIMP functions from external programs as in Script-fu
- Advanced scripting capabilities (Scheme, Python, Perl)
- Plug-ins which allow for the easy addition of new file formats and new effect filters
- Over 100 plug-ins already available
Animation
- Load and save animations in a convenient frame-as-layer format
- MNG support
- Frame Navigator (in GAP, the GIMP Animation Package)
- Onion Skin (in GAP, the GIMP Animation Package)
- Bluebox (in GAP, the GIMP Animation Package)
File Handling
- File formats supported include bmp, gif, jpeg, mng, pcx, pdf, png, ps, psd, svg, tiff, tga, xpm, and many others
- Load, display, convert, save to many file formats
- SVG path import/export

Glickomania project is a puzzle somewhat similar to the samegame.

Gnome clickomania, or glickomania, is a simple, but dangerously addictive puzzle. The objective is to clear the board of all tiles by removing groups of identical adjacent tiles. Tiles fall downwards to fill empty gaps, and from right to left to fill empty columns.

A slight variation of clickomania is known as "the same game" and it has been implemented in KDE (ksame), Gnome (gsame), and most handhelds. The most significant difference is in the scoring: in clickomania the goal is to clear the board, whereas in "same" the objective is to remove as large groups as possible.

Glickomania can be very challenging, but this implementation is designed to be relaxing: there is no clock and the user has unlimited undo and redo.

Contrary to all other implementations I know of, glickomania ensures all problems presented to the player are indeed solvable.

Gnaural is a multi-platform programmable binaural-beat generator, implementing the principles described in October 1973 Scientific American, Gerald Oster, "Auditory Beats in the Brain."

There has been considerable research done on the subject since that publication, and Gnaurals Windows-based predecessor, WinAural, has been used as the audio stimulus in at least one published study, "The Induced Rhythmic Oscillations of Neural Activity in the Human Brain", D. Cvetkovic, D. Djuwari, I. Cosic (Australia), from Proceeding (417) Biomedical Engineering - 2004.

The central finding of Osters article: brain activity can be entrained to the auditory beat frequencies created when each ear is presented simultaneously with tones of slightly offset in frequency. My interest has been exploring how this effect (known as "frequency following response" or "brainwave entrainment") can be used to explore mental states, ranging from profoundly meditative to highly alert.

What are auditory binaural beats?

In 1839, German experimenter Heinrich Wilhelm Dove discovered that playing two tones simultaneously, one in to each ear, induced the perception of a "beat frequency" when the tones were of slightly differing frequency (generally less than 100 Hz apart).

While an acoustic mixing of the two tones will also produce a beat frequency, what is notable about auditory binaural beats is that there is no acoustic mixing of the tones: the beats exist solely within the auditory system. Some researchers believe that they are an artifact of the "neural wiring" used to spatially determine the origins of sounds in our environment.

Gerald Osters breakthrough in 1973 was to observe that the neural processing associated with binaural beats can induce an overall entrainment of brainwave activity (essentially, an oscillation between the two hemispheres in sync with the beat frequency). The neurology of this phenomenon is, according to Oster, tied to the contralateral integration of auditory input taking place in the superior olivary nucleus in the brainstem.

My main interest in the principle has been the possibility that brainwave entrainment can be used to target specific mental states. Gnaural has a long lineage, starting with a DOS program in the mid 1990s, progressing to WinAural for Windows and (in the hope a making a cross-platform solution) BrainJav for Java, and finally the truly cross-platform solution in Gnaural. In over a decade of experience with the technique, I have mainly found it useful for slowing-down brain activity. In that capacity, it has served me in areas ranging from stress reduction, sleep make-up, and particularly as a sort of "poor mans meditation", requiring almost no effort to achieve states of mind that I usually have found rather hard to achieve with real meditation.

But these are strictly my observations, and I make no guarantees about what the technique can do for anyone else. Some of the more unusual applications Ive heard about for my software include sustaining a heightened mental focus for online tournament gaming, and enhancing flotation-tank and related sensory deprivation environments. Many people also apparently use the technique to study more effectively.

One of the stranger facts regarding binaural beats is their seeming ability to be equally-at-home in the laboratory setting as in "grass roots" contexts (such as alternative medicine and the New Age phenomenon). That there is a grass-roots enthusiasm (easily demonstrated by googling binaural beats) is probably related to the sense of promise inherent in an easy-to-implement technique offering the possibility of direct influence of brain behavior. But from a scientific standpoint, there is a big gap between claims (of what binaural beats can do) and corroboration (by scientific method), which has led to a sense in many that the actual subject of binaural beats is "controversial." But this is an irrational response, given that the actual scientific/laboratory basis of binaural beats has remained an established part of the scientific literature for over 30 years.

One of my goals in writing Gnaural was to implement the binaural beat principle within the bounds of my understanding of the established scientific facts regarding the subject. To some extent, this has meant leaving-out many of the "bells and whistles" prevailent in other implementations. That my software has been used for at least one published "hard-science" study suggests that it has been somewhat successful. However, I also hope that Gnaural proves useful for people who wish to explore subjective areas unfettered by scientific rigor. In a subject dealing with matters of the mind, I see both sides -- "grass-roots empiricism" and "scientific empiricism" -- as being complementary halves of a complete investigation of the possibilities, and ultimately, Id hope to see the two sides of our culture be catalysts for each other, rather than inhibited by a mutual antagonism.