Free rare coins software for linux

Super Mario Clone FX is a jump-and-run game in the style of Super Mario World. Secret Maryo Chronicles is a two-dimensional, sidescrolling jump-and-run platform game which utilizes the platform independent multimedia library, SDL.
It features a built-in level editor which can be used to easily create your own levels.
Main features:
In-Game Level Editor
- Activated by F8 in the game. You can insert any graphic file as a background or massive sprite in the game.
- Many standart graphics like hedges and ground sprites are included. You can insert enemys, set the players start position on the level,
- insert active sprites, and create half-massive sprites which the player can jump through, but can not fall through.
Multiple Levels
- Each level ends with gate or pipe, press up or down to enter the next level.
Multiple Maryo Stages
- Includes small Maryo, normal Maryo, and fire Maryo. Advance to the next stage by getting mushrooms and fire plants.
- These items can be obtained by jumping into question mark boxes.
Overworld
- Get an aerial perspective between levels, just like the World Map in Super Mario World.
Great Sounds and Music
- High quality Ogg music and sounds for the EXTRA maryo game feeling.
Save and Load
- Save anytime from the game menu. Then load whenever you want.
Get Extra Lives
- By getting 100 coins or finding the Green Mushrooms.

CoinXtension offers some additional operators for existing data types of Coin 3D; but more important it extends the linear algebra capabilities of the original framework, by adding the new data type C3Xt_matrix3d, that offers such usefull routines as for eigenvalue or QR-decomposition.
CoinXtension library only depends on Coin 3d and libstdc++, thus it should work on all plattforms on which Coin 3D is available, altough it was developed and tested only on Linux/x86.
This is the first release and the software is still alpha, so dont expect it to be exactly the same in some days or weeks, nor that it works the way you imagined!
Furthermore the development of the library is not really a directed process, but i integrate new features as i come accross things in projects that might usefull in future ones too.
Enhancements:
- Support for Euler angles and many bugfixes.

Coinflip provides a cryptographically secure server/client program and protocol for choosing random bits.

Coinflip is a client/server based program that can generate random bits for 2 people over the internet. The 2 people dont have to trust each other in order to convince each other that the bit is truly a random bit.

Its called coinflip, of course, because flipping a coin in the real world is the equivalent of generating a random bit on a computer. (Its either heads or tails. Its either a 1 or a 0.)

Coinflip uses a slightly modified version of the "Coin Flipping Using One-Way
Functions" protocol outlined in Bruce Schneiers Applied Cryptography 2nd
edition.

This attack would work everytime Alice acted as the server in a coinflip procedure, providing Bob never realized that Alice was sending him the same y value every time. Or she could us it to trick multiple Bobs.

While it is supposed to be computationally infeasible to compute collisions in one-way hash functions, recent papers suggest that if you have enough money and time, collisions can be precalculated. P. van Oorschot and M. Wiener in their paper, "Parallel collision search with application to hash functions and discreet logarithms", estimate that for $10 million (in 1994 US dollars), a collision could be found for MD5 in 24 days on average. (Thanks for the info, defrost).

The solution is actually quite simple: Have both parties choose part of the random data, and use whatever size random number you like. Since Bob is expecting to see x contain his random data, Alices collision attack is nullified, and since Alice gets to put in her own data, she can make Bobs array attack infeasible.

Evocosm is a C++ Framework for Evolutionary Computing library.
Evocosm is a set of classes that abstract the fundamental components of an evolutionary algorithm. Ill list the components here with a bit of introduction; you can review the details of the classes by downloading the code archives or by reviewing the online documentation (see the menu at the articles beginning for code and documentation links.)
All class documentation was generated from source code comments using doxygen. These docs have not been thoroughly proofread, so they may contain a few typos and minor errors. Self-publishing has taught me the value of a good proofreader.
Evolutionary algorithms come in a variety of shapes and flavors, but at their core, they all share certain characteristics: populations that reproduce and mutate through a series of generations, producing future generations based on some measure of fitness. An amazing variety of algorithms can be built on that general framework, which leads me to construct a set of core classes as the basis for future applications.
The classes include:
Random Numbers
Evocosm relies on the code in The Twisted Road to to Randomness for random number generation. The Mersenne Twister algorithm is particularly well-suited to evolutionary algorithms, based on its long period, granularity, "randomness", and speed. As of the 2.1.0 release of libevocosm, the mtprng class resides in libcoyote, and not libevocosm as it did earlier. This means that any program using libevocosm must also link against libcoyote.
Validation
To validate function arguments, Evocosm uses the code I describe in Beyond Assert; this code is part of libcoyote. Any program using libevocosm must also link against libcoyote.
Floating- Point Chromosomes
Evcosom supports the crossover and mutation of IEEE-754 floating-point numbers, using an algorithm I invented in the mid-1990s. This topic is covered in detail here.
Roulette Wheels
The roulette_wheel class implements the concept of a "software roulette wheel" for Evocosm. This is a tool for natural selection, wherein the fitness of an organism determines the width of its "slot" on an imaginary roulette wheel.
Organisms
Think of an "organism" as an answer to a problem posed by a fitness landscape; "genes" define its behavior and an associated fitness value is assigned by an evocosm during testing. Evocosm provides the freedom to define organisms as almost anything: bit strings, floating-point numbers, finite state machines, LISP programs, or external robots controlled via radio waves. In A Complexity of Options, I used an Evocosm-derived GA to determine the gcc options that produce the faster code.
Fitness Landscapes
A "fitness landscape" defines the environment where organisms "live" or a problem that they are tested against. The landscape is intimately tied to the nature of the organism; think of an organism as a potential solution to a problem implemented by the landscape. A floating-point organism, for example, could be tested by a fitness landscape that represents a function to be maximized. Or, an organism describing the shape of wing could be tested by a landscape that simulates a wind tunnel.
Evocosms
The evocosm class binds a population of organisms to a set of objects that define the rules of survival and reproduction. An evocosm will have one or more populations, which will evolve against population-unique and shared (common) fitness landscapes; breeding is controlled by a set of class objects from the following classes.
Fitness Scaling
As a population converges on an "answer", the difference between fitness values often becomes very small; this prevents the best solutions from having a significant advantage in reproduction. Fitness scaling solves this problem by adjusting the fitness values to the advantage of the most-fit chromosomes. Evocosm includes a variety of fitness scaling algorithms.
Migration
A migrator removes individuals (via "emigration") from a population of organisms, transferring them to another population (via "immigration"). The only concrete implementation of this interface is random_pool_migrator, which defines a specific number of organisms that may migrate from each population to another. When creating a random_pool_migrator, specify the number of organisms that can migrate from each population. Migration is, of course, meaningless in any application that has only one population.
Selecting Survivors
A selector decides which organisms survive from one generation to the next. Some evolutionary algorithms will not use a selector; other will. In general, it is effective to keep the "best" organisms from one generation to the next, so that good genes do not become lost at random. This is, of course, an improvement on nature, where being "the best" doesnt guarantee survival.
Reproduction
In most cases, a reproducer generates new organisms using parents selected (by fitness) from an existing population. In some singular (and probably rare) cases, a reproducer might generate new, random organisms in order to keep diversity high. Reproduction techniques can include crossover and asexual, sexual and (my favorite) try-sexual models.
Mutation Operators
A mutator applies mutations (random, usually small changes) to a set of organisms. Mutation is highly dependent on the type of organism. In traditional genetic algorithms, a mutation flips one or more bits in an integer (i.e., chromosome). Evolving a path for the Traveling Salesman Problem involves complex mutations that maintain valid permutations of destination points; in the case of floating-point numbers, Ive provided utilities for mutating and crossing IEC-60559 (IEEE- 754) float and double types.
Enhancements:
- Minor bugfixes, code cleanups, and changes to pseudo-random number generators.
- Now includes Visual Studio 2005 projects along with GNU build files.

SrvReport is a simple and featurefull server monitoring and reporting system. SrvReport project can send every day a mail with the latest state of the server including:
- network traffic report
- cpu usage report
- mail send/receive
- server warnings
- last logins
- other customized messages (like harddisk problems)
- web-server traffic report
- Xfer-logs (ftp)
- optional test for rootkits (with chkrootkit)
Main features:
A full report will show you the following information:
- Network traffic (including dayly, weekly and monthly graph)
- CPU-Usage (including dayly, weekly and monthly graph)
- Mail sent/receive report (to, from, size)
- Last authenticated users
- Server warnings
- Other customized messages (like harddisk problems)
- Optional web-server traffic report
- Optional Xfer-logs
- Optional test for rootkits (with chkrootkit)
It supports the following features as well:
- Several languages
- No need of rare perl libraries
- Easy to use (Just one configuration file to edit),
- Free (GNU GPL), with sources (perl scripts),

TRE is a robust, lightweight, and efficient POSIX compliant regexp matching library with some exciting features such as approximate (fuzzy) matching.
At the core of TRE is a new algorithm for regular expression matching with submatch addressing. The algorithm uses linear worst-case time in the length of the text being searched, and quadratic worst-case time in the length of the used regular expression.
In other words, the time complexity of the algorithm is O(M2N), where M is the length of the regular expression and N is the length of the text. The used space is also quadratic on the length of the regex, but does not depend on the searched string. This quadratic behaviour occurs only on pathological cases which are probably very rare in practice.
Main features:
- TRE is not just yet another regexp matcher. TRE has some features which are not there in most free POSIX compatible implementations. Most of these features are not present in non-free implementations either, for that matter.
Approximate matching
Approximate pattern matching allows matches to be approximate, that is, allows the matches to be close to the searched pattern under some measure of closeness. TRE uses the edit-distance measure (also known as the Levenshtein distance) where characters can be inserted, deleted, or substituted in the searched text in order to get an exact match. Each insertion, deletion, or substitution adds the distance, or cost, of the match. TRE can report the matches which have a cost lower than some given threshold value. TRE can also be used to search for matches with the lowest cost.
TRE includes a version of the agrep (approximate grep) command line tool for approximate regexp matching in the style of grep. Unlike other agrep implementations (like the one by Sun Wu and Udi Manber from University of Arizona available here) TRE agrep allows full regexps of any length, any number of errors, and non-uniform costs for insertion, deletion and substitution.
Enhancements:
- A Swedish translation has been added.
- Documentation has been updated.
- The -q command line option has been added.
- A number of bugs have been fixed.

Jarmor is a tiny collection of java filters implementing ASCII armors.
ASCII armors are data converters between binary format and textual format. They are used for example by mailers to handle mail attachements. They can also be used for example to store binary data in an otherwise textual format, for example XML.
Several popular encoding algorithms exists. They all rely on a small subset of ASCII for the textual format and they all increase the size of the encoded data with respect to the raw binary data. Jarmor supports encoding and decoding using the Base64, Base32, Base16, UUCP and ASCII85 encodings.
These classes extends java.io.FilterInputStream for the decoders and java.io.FilterOutputStream for the encoders. This allows to put them simply in data streams and encode/decode binary streams on the fly.
Enhancements:
- An error in ASCII85Decoder was fixed.
- This error occurred for specific rare byte combinations in the last data chunk when it was not complete (i.e. less than four bytes).
- The encoding class was not affected by the error.
- Jarmor is now considered stable and known to be used in critical production environments.