Free round trip flights software for linux

Splendid City Team Sports Scheduler, and Sports Scheduling Software System is useful for people who organize team sports or game events. It can manage sports schedules of any size and complexity. Simply fill in the requested information into the wizard like interface, and Splendid City automates the season, tournament, league, match, round-robin and practice schedules.

A great first step and time saving tool for anyone who frequently does organizational sports scheduling. Splendid City can schedule sports with any user specified combination of dates and times. Create professional double or single elimination tournaments brackets, round-robin league schedules, swiss round tournaments, cross divisional or practice schedules for any sport that requires pairings.

It features options that include the ability to set team and field constraints, game lengths; configurative time management utilities to help you organize events the way you would like; object constraint sharing; automatic schedule generation and re-generation; configurative project web site creation, tournament brackets; publishing via FTP, export to HTML, CSV, iCalendar, XML; import from CSV; standings support with tie-breaker formulas; contact management; import teams, fields, officials, players and player rosters from other users projects ; constraint and conflict checking and resolution.

Users can freely exchange all data associated with projects with other users who have a free copy of Splendid City Lite installed regardless of platform. The application comes with an integrated e-mail client that can aid with the exchange of object files among organization members. There is also a simple FTP client for direct uploading to web domains from within the schedule view frame.

The scheduler gives you complete control over all aspects of the schedule, and creates solutions effortlessly and elegantly in accordance with the user data entered. It can be custom-tailored, and with repeated use via a plugin interface, can be made to automatically accomplish users unique scheduling needs.

The user experience is interactive and straight forward. The application comes fully documented with a built in searchable help system to provide answers to implementation questions.

TRIP is a general computer algebra system dedicated to celestial mechanics. TRIP includes a numerical kernel and has interfaces to gnuplot and xmgrace.
Computations can be performed with double, quadruple, or multi-precision. Users can dynamically load external libraries written in C, C++, or Fortran.
Enhancements:
- Several bugs in the frequency analysis functions were fixed.
- The screen refresh on the Windows graphical user interface was improved.
- A problem in the communication with the plotting tool grace was fixed.

]project-open[ software is an open-source based project management system.
Functionality include internet collaboration and e-Rooms, discussion forums, Internet filestorage, customer management (CRM), timesheet management, management accounting with profit & loss per project, basic human resources management (HR), provider & freelance database, search engine, reporting, translation workflow and many more. We are currently working on four different "vertical solutions".
]project-open[ is a very complete online platform and already contains today many of the feature that are currently announced by many large international companies.
We can provide these features thanks to the open-source nature of ]project-open[ that allows us to tap into thousands of manyears of development time from other open-source projects such as OpenACS, AOLServer, PostgreSQL, CygWin, CVS, Postfix, Linux, Pound, Inno Setup, etc.
Additional modules: Data Warehouse, Room Reservation, e-Commerce, Automatic Testing, Content Management, Events, Bug Tracker, Categorysation, Wiki, RSS Support, Blog, WebDAV, Soap & XML-RPC, Calendar, Performance Profiling, CRM Campaigns, Jabber Integration, Filestorage, Glossary Database, News Aggregator, Online Surveys, Webmail.
]project-open[ is useful for project-oriented companies such as IT consultancies, general consultancies, advertizing agencies, etc. It is not very suitable for companies dealing with physical goods, because it doesnt contain the necessary modules (yet). Checkout Compiere or Open for Business as alternatives.
Enhancements:
- More than a dozen new modules and features have been included, including a round-trip integration with GanttProject, resource planning and resource assignments, GUI improvements, a new calendar module to show tasks and deadlines, a new bug tracker module, a new expenses and travel costs module, a new reporting engine, a new Petri-Net workflow engine with a graphical editor, project templates, and a new "configuration wizard" for automatic system configuration.

Label Templates are free Opendocument Format label templates for Openoffice.org, KOffice or any other Office suite ODF ready for making labels.

Collection includes CD, DVD, address, mailing, round, media label templates, Avery sizes and more. US Letter size and 14 size paper formats available.

Setup time is quick with these templates and printing labels from these templates is easy.

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.

The Wonder Shaper is a very special network shaper script with a lot of features. Works on Linux 2.4 & higher.

Goals

I attempted to create the holy grail:

* Maintain low latency for interfactive traffic at all times.

This means that downloading or uploading files should not disturb SSH or even telnet. These are the most important things, even 200ms latency is sluggish to work over.

* Allow surfing at reasonable speeds while up or downloading

Even though http is bulk traffic, other traffic should not drown it out too much.

* Make sure uploads dont harm downloads, and the other way around

This is a much observed phenomenon where upstream traffic simply destroys download speed. It turns out that all this is possible, at the cost of a tiny bit of bandwidth. The reason that uploads, downloads and ssh hurt eachother is the presence of large queues in many domestic access devices like cable or DSL modems.

Why it doesnt work well by default

ISPs know that they are benchmarked solely on how fast people can download. Besides available bandwidth, download speed is influenced heavily by packet loss, which seriously hampers TCP/IP performance. Large queues can help prevent packetloss, and speed up downloads. So ISPs configure large queues.

These large queues however damage interactivity. A keystroke must first travel the upstream queue, which may be seconds (!) long and go to your remote host. It is then displayed, which leads to a packet coming back, which must then traverse the downstream queue, located at your ISP, before it appears on your screen.

This HOWTO teaches you how to mangle and process the queue in many ways, but sadly, not all queues are accessible to us. The queue over at the ISP is completely off-limits, whereas the upstream queue probably lives inside your cable modem or DSL device. You may or may not be able to configure it. Most probably not.

So, what next? As we cant control either of those queues, they must be eliminated, and moved to your Linux router. Luckily this is possible.

Limit upload speed somewhat

By limiting our upload speed to slightly less than the truly available rate, no queues are built up in our modem. The queue is now moved to Linux.

Limit download speed

This is slightly trickier as we cant really influence how fast the internet ships us data. We can however drop packets that are coming in too fast, which causes TCP/IP to slow down to just the rate we want. Because we dont want to drop traffic unnecessarily, we configure a burst size we allow at higher speed.

Now, once we have done this, we have eliminated the downstream queue totally (except for short bursts), and gain the ability to manage the upstream queue with all the power Linux offers.

Let interactive traffic skip the queue

What remains to be done is to make sure interactive traffic jumps to the front of the upstream queue. To make sure that uploads dont hurt downloads, we also move ACK packets to the front of the queue. This is what normally causes the huge slowdown observed when generating bulk traffic both ways. The ACKnowledgements for downstream traffic must compete with upstream traffic, and get delayed in the process.

We also move other small packets to the front of the queue - this helps operating systems which do not set TOS bits, like everything from Microsoft.

Allow the user to specify low priority traffic (new in 1.1!)

Sometimes you may notice low priority OUTGOING traffic slowing down important traffic. In that case, the following options may help you:

NOPRIOHOSTSRC
Set this to hosts or netmasks in your network that should have low priority

NOPRIOHOSTDST
Set this to hosts or netmasks on the internet that should have low priority

NOPRIOPORTSRC
Set this to source ports that should have low priority. If you have an unimportant webserver on your traffic, set this to 80

NOPRIOPORTDST
Set this to destination ports that should have low priority.

See the start of wshaper and wshaper.htb

Results

If we do all this we get the following measurements using an excellent ADSL connection from xs4all in the Netherlands:

Baseline latency:
round-trip min/avg/max = 14.4/17.1/21.7 ms

Without traffic conditioner, while downloading:
round-trip min/avg/max = 560.9/573.6/586.4 ms

Without traffic conditioner, while uploading:
round-trip min/avg/max = 2041.4/2332.1/2427.6 ms

With conditioner, during 220kbit/s upload:
round-trip min/avg/max = 15.7/51.8/79.9 ms

With conditioner, during 850kbit/s download:
round-trip min/avg/max = 20.4/46.9/74.0 ms

When uploading, downloads proceed at ~80% of the available speed. Uploads at around 90%. Latency then jumps to 850 ms, still figuring out why.

What you can expect from this script depends a lot on your actual uplink speed. When uploading at full speed, there will always be a single packet ahead of your keystroke. That is the lower limit to the latency you can achieve - divide your MTU by your upstream speed to calculate. Typical values will be somewhat higher than that. Lower your MTU for better effects!

A small table:

Uplink speed | Expected latency due to upload
--------------------------------------------------
32 | 234ms
64 | 117ms
128 | 58ms
256 | 29ms

So to calculate your effective latency, take a baseline measurement (ping on an unloaded link), and look up the number in the table, and add it. That is about the best you can expect. This number comes from a calculation that assumes that your upstream keystroke will have at most half a full sized packet ahead of it.

This boils down to:

mtu * 0.5 * 10
-------------- + baseline_latency
kbit

The factor 10 is not quite correct but works well in practice.

Your kernel

If you run a recent distribution, everything should be ok. You need 2.4 with QoS options turned on.

If you compile your own kernel, it must have some options enabled. Most notably, in the Networking Options menu, QoS and/or Fair Queueing, turn at least CBQ, PRIO, SFQ, Ingress, Traffic Policing, QoS support, Rate Estimator, QoS classifier, U32 classifier, fwmark classifier.

In practice, I (and most distributions) just turn on everything.

The scripts

The script comes in two versions, one which works on standard kernels and is implemented using CBQ. The other one uses the excellent HTB qdisc which is not in the default kernel. The CBQ version is more tested than the HTB one!

See wshaper and wshaper.htb.

Tuning

These scripts need to know the real rate of your ISP connection. This is hard to determine upfront as different ISPs use different kinds of bits it appears. People report success using the following technique:

Estimate both your upstream and downstream at half the rate your ISP specifies. Now verify if the script is functioning - check interactivity while uploading and while downloading. This should deliver the latency as calculated above. If not, check if the script executed without errors.

Now slowly increase the upstream & downstream numbers in the script until the latency comes back. This way you can find optimum values for your connection. If you are happy, please report to me so I can make a list of numbers that work well. Please let me know which ISP you use and the name of your subscription, and its reputed specifications, so I can list you here and save others the trouble.

Installation

If you dial in, you can copy the script to /etc/ppp/ip-up.d and it will be run at each connect.

If you want to remove the shaper from an interface, run wshaper stop. To see status information, run wshaper status.

KNOWN PROBLEMS

If you get errors, add an -x to the first line, as follows:

#!/bin/bash -x

And retry. This will show you which line gives an error. Before contacting me, make sure that you are running a recent version of iproute!

Recent versions can be found at your Linux distributor, or if you prefer compiling, here:
ftp://ftp.inr.ac.ru/ip-routing/iproute2-current.tar.gz

GridMPI is a new open-source free-software implementation of the standard MPI (Message Passing Interface) library designed for the Grid. GridMPI project enables unmodified applications to run on cluster computers distributed across the Grid environment.
GridMPI team found that it is feasible to connect cluster computers and to run ordinary scientific applications in distance upto 500 miles. Simple experiment has shown that most MPI benchmarks scale fine upto 20 millisecond round-trip latency which corresponds to about 500 miles in distance, when the clusters are connected by fast 1 to 10 Gbps networks. 500 miles covers the major cities between Tokyo--Osaka in Japan.
Thus, applications which are too large to run on a local cluster should run on multiple clusters in the Grid environment with acceptable performance. However, it is only feasible when using an efficient MPI implementation [1]. Existing implementations are not efficient enough mainly because of the two reasons: their focus on security features and TCP performance problems.
GridMPI skips security layers assuming dedicated secure links. The institutes housing large clusters tend to have their own networks to connect to other institutes in most cases. GridMPI so focuses on the performance on TCP. Since existing implementations are in most cases designed for MPP machines and recently clusters with special hardware, their performance on TCP with Ethernet is not optimal.
Also TCP performance itself is not optimal for the work load of the MPI traffic. In addition, support for heterogeneous combinations of computers of the existing MPI implementations is not satisfactory. Thus, GridMPI is designed and implemented from the scratch. GridMPI is carefully coded and tested with heterogeneity in mind.
Main features:
- Full conformance to the standard: GridMPI passes 100% of the functional tests of the large test suites from ANL and Intel (MPI-1.2 level).
- Full heterogeneity support: GridMPI is fully tested with combinations of processors of 32bit/64bit and big/little-endian.
- Primary support of TCP/IP and sockets: GridMPI is written from scratch and it is new and clean. It is efficient with sockets, and thus suitable for the Grid as well as ordinary Ethernet-based clusters.
- Cooperation with Grid job submission: GridMPI can be used with Globus, Unicore, tool from NAREGI project, etc.
- Checkpointing support: GridMPI supports checkpointing on Linux/IA32 platforms to restart long-running applications from failure.
- Vendor MPI support: GridMPI supports IBM-MPI, Fujitsu-Solaris-MPI, Intel-MPI, and any MPICH-based MPI for clusters with special communication hardware.
Enhancements:
- Minor bugfixes were made.