Free robin hood software for linux

DOLFIN project is the C++ interface of FEniCS, providing a consistent PSE (Problem Solving Environment) for solving ordinary and partial differential equations.
Main features:
- Simple, consistent and intuitive object-oriented API
- Automatic and efficient evaluation of variational forms through FFC
- Automatic and efficient assembly of linear systems
- Support for general families of finite elements, including continuous and discontinuous Lagrange finite elements of arbitrary order on triangles and tetrahedra through FIAT
- Support for arbitrary mixed elements, including Taylor-Hood
- High-performance parallel linear algebra through PETSc with simple C++ wrappers
- Triangular and tetrahedral meshes, including adaptive mesh refinement and mesh hierarchies
- Multi-adaptive mcG(q)/mdG(q) and mono-adaptive cG(q)/dG(q) ODE solvers
- Support for a range of output formats for post-processing, including DOLFIN XML, MATLAB, Octave, OpenDX, GiD, Tecplot and Paraview/VTK
- SWIG-generated Python interface PyDOLFIN (experimental) in addition to the standard C++ interface

OBEXFTP Front-End is very effective Java Swing application that uses the ObexFTP under the hood to make easier to manipulate the file system of OBEX-enabled devices.
The Open OBEX project, which is an open source project hosted in SourceForge.net, is the most successful implementation of the OBEX (OBject EXchange) protocol for Open Source Unix-based Operating Systems. Besides, it supports a wide range of devices of different models and vendors.
The only bad thing about this project is that the Open OBEX is a set of command-line programs, and they are not so friendly to the end users. We have been using the Open OBEX for some time, and we felt the need of a friendly user interface to make things easier for us - the users.
So, ObexFTP front-end is a simple - but nice - Java Swing application that uses ObexFTP under the hood to make easier to manipulate the file system of OBEX-enabled devices.
Main features:
- navigate through the devices files;
- create folders in the device;
- send file(s) to the device;
- download file(s) to your computer;
- delete files and folders;
The ObexFTP has been tested in the following Operating Systems:
- Slackware 12.0
- Ubuntu 7.0.4
If youre successfully running ObexFTP front-end in other Operating System than those listed here, please let us know!

fping is a ping like program which uses the Internet Control Message Protocol (ICMP) echo request to determine if a host is up. fping is different from ping in that you can specify any number of hosts on the command line, or specify a file containing the lists of hosts to ping.

Instead of trying one host until it timeouts or replies, fping will send out a ping packet and move on to the next host in a round-robin fashion.

If a host replies, it is noted and removed from the list of hosts to check. If a host does not respond within a certain time limit and/or retry limit it will be considered unreachable.

Unlike ping, fping is meant to be used in scripts and its output is easy to parse.

Problem and Issues:

With a large a number of IP addresses in use, its becomes more and more time consuming to check on which IP addresses are actively in use, and which critical machines (routers, bridges, servers, etc) are reachable. One example is we have a program which goes through all of our routers arp caches looking for IP addresses that are in use. After finding a list of IP addresses that arent in any arp caches fping can then be used to see if these IP addresses really arent being used, or are just behind the routers. Checking 2500 hosts (99% of which are unreachable) via ping can take hours.

fping was written to solve the problem of pinging N number of hosts in an efficient manner. By sending out pings in a round-robin fashion and checking on responses as they come in at random, a large number of hosts can be checked at once.

Unlike ping, fping is meant to be used in scripts and its output is easy to parse.

OSSP flow2rrd is a companion tool to the Flow-Tools toolkit for storing NetFlow network traffic data in an accumulating fixed-size RRDTool Round-Robin-Database (RRD) for visualization purposes.
This file is piece of OSSP flow2rrd, a tool for storing NetFlow data into an RRD which can be found at http://www.ossp.org/pkg/tool/flow2rrd/.
Enhancements:
- Created the initial version of OSSP flow2rrd.

Balance is our suprisingly successful load balancing solution being a simple but powerful generic tcp proxy with round robin load balancing and failover mechanisms.
Balance behaviour can be controlled at runtime using a simple command line syntax.
Balance successfully runs at least on Linux(386), Linux(Itanium), FreeBSD, BSD/OS, Solaris, Cygwin, Mac-OS X, HP-UX and many more.
Balance is Open Source Software and released under GPL licensing terms.
Balance has been released the first time in June 2000 and has just celebrated its fifth anniversary.
Enhancements:
- A bug in the autodisable functionality has been fixed.
- The manual page has been updated.

Games::Tournament::RoundRobin is a Perl module for Round-Robin Tournament Schedule Pairings.

SYNOPSIS

$schedule = Games::Tournament::RoundRobin->new;

$pairings = $schedule->indexesInRound($roundm);
$round = $schedule->meeting($member1, [$member2, $member3]);
...

Every member of a league of 2n players can be paired with every other member in 2n-1 rounds.

If the league members are (Inf, 1 .. 2n-1), then in round i, i can be paired with Inf, and a can meet b, where a+b = 2i (mod 2n-1).

METHODS

new

Games::Tournament::RoundRobin->new( v => 5, league => [Ha, Be, He])
Games::Tournament::RoundRobin->new( league => {A => $a, B => $b, C => $c})
where v (optional) is the number of league members, and league (optional) is a list (or a hash) reference to the individual unique league members. One of v, or league (which takes precedence) is necessary, and if league is not given, the members are identified by the numbers 0 .. n-1.

If the league is a list (or hash) of n objects, they should be instances of a class that overloads both string quoting with a name method and arithmetical operations with an index method. The index method, called on the n objects in order, should return the n numbers, 0 .. n-1, and in that order if they are presented as an array. If they are presented as a hash, the hash is stored internally as an array and the keys are discarded.

If the league is a list of strings or numbers, indexes are constructed for the values on the basis of their positions in the list, and if a hash of strings or numbers, on the basis of the lexicographic order of their keys. Each string is expected to be unique.
If n is odd, an additional n-1, Bye or object (a Games::League::Member object, by default) member, depending on the type of the first member in the league, is added at the end and n is increased by 1.
indexesInRound

$schedule->indexesInRound($m)

Returns an array reference of the pairings in round $m. This method is useful if you are using numbers to represent your league members. It is not so useful if you are using strings or objects and you dont know their index numbers. Positions in the array represent members. The values represent their partners. Each member is thus represented twice.

roundsInTournament

$t = $schedule-> roundsInTournament;
$round1 = $t[0];
$inRound1FourthWith = $t->[0]->[3];
$inLastRoundLastWith = $$t[-1][-1];

Returns, as a reference to an array of arrays, the pairings in all rounds of the tournament. This method is useful if you are using the algorithm indexes.
partner

$schedule->partner($member, $m)

Returns the partner of $member in round $m.

membersInRound

$schedule->membersInRound($m)

Returns an hash reference of the pairings in round $m. This method is useful if you are using strings or objects. Keys in the hash represent league members. If the league members are objects, their names are used as keys. If 2 names are the same, the names are changed to $name.1, $name.2 etc. The values are their partners. Each player is thus represented twice.

memberSchedule

$schedule->memberSchedule($member)

Returns, as an array reference, the partners who $member is matched with in the order in which they meet, ie round by round.

meeting

$schedule->meeting($member,$partner)

Returns the rounds (TODO and the venue) at which $member meets $partner.

meetings

$schedule->meetings($member1,[$member2,$member3,...])

Returns, as an array reference, the rounds (TODO and the venue) at which $member1 meets $member2, $member3, ...

index

$schedule->index($member)

Returns $members index, the number which is used to pair it with other members. The index is the position, 0..n-1, of the $member in the league argument to the constructor (if an array) or the constructed array (if a hash.)
If $member is not a member of the array, or is itself an index, undef is returned.

member

$schedule->member($index)
$schedule->member($name)
$bye = $schedule->member( $schedule->size-1 )

Returns the member represented by $index, a number which ranges from 0..n-1, or by $name, a string. If there is no such member, undef is returned.

partners

$schedule->partners($index)
$schedule->partners($name)

Returns an array reference of all the partners of the $indexed or $named member, in index order, or the order in the league argument.

realPartners

$schedule->realPartners($index)

Returns an array reference of all the partners of the $indexed member, excluding the Bye member. Dont use this if you have no Bye member, as it just leaves off the last member.

size

$schedule->size

Returns the number of members in the round robin. Sometimes this may not be the same as the number of league members specified, because the array of league members takes precedence if supplied, and a bye is added if the number is odd.

rounds

$schedule->rounds

Returns the number of rounds in the round robin. This equals the number of league members, minus 1.

SuperShaper-SOHO is a traffic shaping setup for DSL connections which prioritizes VoIP and interactive traffic and makes sure P2P traffic doesnt saturate your uplink.
IPCop 1.3 and newer is known to work and is the preferred deployment setup. Firstly, be sure to disable the integrated traffic shaper in IPCop 1.4 if you use SuperShaper-SOHO.

OSCache is a high performance J2EE caching solution that can cache portions of JSP pages, entire HTTP responses (including dynamically generated images), and arbitrary Java objects.
OpenSymphony Cache can provide your J2EE application with huge performance gains and graceful error tolerance (e.g., in the event of a DB failure, cached content is served).
Fast in-memory caching
OSCache allows you to execute dynamic content periodically (eg every 30 minutes) rather than every request and store the result in memory. Each further request is served directly from the memory cache, resulting in dramatic speed increases.
The cache is keyed programmatically. This means you can calculate a cache key that works for your situation. For example an ecommerce site might use product ID as keys, or content site might use an article date and article ID combination.
The cache is stored in standard scopes that any JSP programmer is familiar with (application or session). The session scope allows you to have different cached content per user. This is one unlike any other caching system weve ever seen.
Persistent on-disk caching
OSCache can also write the cache to disk. This provides caching across server restarts, and caching of datasets that do not fit into memory. Caching can be configured to use memory or file caching, or a combination of both.
If you want to persist the cache to somewhere other than disk, you can plug in a custom PersistenceListener. This allows you to persist the cache to anywhere (for example to a database via JDBC or to LDAP via JNDI).
When using both disk caching and memory caching. It is possible to limit the cache size to avoid using too much memory but let disk cache unlimited, resulting in browser style complementary disk cache. When cached objects are removed from memory, they are still on disk. If the item is needed again and it is not expired the cache file will be used. This also gives fault tolerance if the server crashes.
Persistence can also be switched to overflow mode using the property oscache.persistence.overflow.only. This changes the default behavior (of persisting every cache entry when there is a listener) to only persist when the memory cache capacity has been reached.
Excellent Performance
Written with performance in mind.
Mulitple cache requests can be handled concurrently.
Only one requesting thread needs to update an expired cache entry even if multiple threads are requesting it simultaneously. Other threads can be configured to either receive the recently-expired object, or block until the cached object is updated. Similarly, when a new entry is being added to the cache, other threads requesting that entry will block until it is ready rather than run off and race to build the same object. In a high load environment this can provide enormous performance benefits.
Automatically takes advantage of JRE 1.4 or higher if available.
Clustering support
OSCache can easily be configured to cluster across multiple boxes. This provides both scalability and failover support without any changes required in your caching code.
Flexible Caching System
OSCache allows you to cache portions of JSP pages, arbitrary Java objects, and even entire servlet responses.
Cache capacity can be set allowing you to limit the number of cached objects.
Multiple caching algorithms are supported such as LRU (Least Recently Used), FIFO (First In First Out), or unlimited. It is also possible to plug in your own custom algorithm.
You are given a huge amount of control over the way cached objects expire. Objects can be cached indefinitely, expired once they reach a certain age, or expired based on a cron expression. Programmatic flushing is also possible, and if that is still not enough pluggable RefreshPolicies allow custom refresh strategies.
Cached objects can be grouped together however you like, allowing for powerful management of cached data. This is an extremely useful feature that is far more powerful than what other caching solutions typically offer (such as the flushing of cache keys that match a particular pattern).
Fully event driven! OSCache fires events for various happenings under the hood such as cache entry events (adding, updating, flushing and removing) and cache accesses (hit, stale hit and miss). It is easy to add your own event handlers.
Multiple caches can be created, each with their own unique configuration.
Simple JSP Tag Library
The tag library to perform and control the caching is very simple. See the Tag Reference for more information.
Caching Filter
A Servlet 2.3 Filter allows for caching of entire pages and generated binary files (like dynamically created images or PDF files).
Comprehensive API
For the ultimate control, OSCache can be used through its straightforward API. You can instantiate, configure and control multiple caches programmatically. It would be possible for example to create one small in-memory cache that held currency conversion rates and was updated daily at 2am, while another cache could be purely disk based and used for holding dynamically created images.
Exception Handling
OSCache provides a way for your site to gracefully tolerate errors. This is not error prevention, rather if an error occurs it should not stop your site from functioning. For example if your database goes down, normally your product descriptions will not be browsable. Using OSCache you can cache those descriptions so you can still browse them.
Cache Flushing
Flushing of caches can be controlled via JSP Tags, so these functions can easily be built into your administration interface.
There is programmatic control over what caches are flushed (eg all caches or just a particular scope).
Cached objects can be expired in a number of ways. Objects can be told to expire once they reach a certain age, or, through the use of cron expressions, on particular dates and/or times (eg it is trivial to make an object expire every weekday at 3am). If this is not enough, you can expire objects programmatically as required, or plug in your own custom RefreshPolicy class that can dynamically decide when an object should be flushed.
Entire groups of objects can be easily flushed from the cache. For example suppose you were caching product data as well as entire pages of your website. When a product was updated, you could flush not just the product object but also all the pages that contain information about that product. No more waiting for the cached objects to expire before the updated content shows up on your site!
Portable caching
Pure Java, this means it is platform independent.
OSCache is compliant with Servlet 2.3 and JSP 1.2 standards, which means it should work in the latest generation of servlet containers and application servers.
i18n Aware
The caching is i18n aware and supports all encodings.
Solid Reputation
Thousands of downloads, hundreds of users on the mailing list.
Comprehensive JUnit test suite that covers every aspect of OSCache, including a web stress test and various concurrent cache access scenarios. To back this up, the kind folks at Cortex have supplied us with a Clover license to provide detailed code coverage analysis of our unit tests.
We have solid issue tracking using JIRA to keep track of any feature requests, bug reports and development progress. JIRA is provided courtesy of Atlassian.
Enhancements:
- CRON expressions to expire content at specific dates and/or times.
- Pluggable EntryRefreshPolicy.
- Reduced memory consumption.
- Faster disk persistence.
- DiskPersistenceListener deadlocks are avoided if a process has no rights to delete the cache file.
- There is a new JSP tag _addgroups_, and an interface to get a list of the cache event listeners.
- The commons collection dependency has been removed.
- Java 1.3 support has been dropped.