new

        Games::Tournament::RoundRobin->new( v => 5, league => [qw/Ha Be He/])
        Games::Tournament::RoundRobin->new( league => {A => $a, B => $b})

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.

TODO This was not such a good idea. v should not change if it is odd. That is the size of the league is the number of real members. The Bye member should not be included. This will require some refactoring.

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 don't 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.

wholeSchedule

        $schedule->wholeSchedule();

Returns a reference to an array of arrays, with each of the latter 2-element arrays representing the players in each match in each round. Thus, you can iterate through the top-level array and inner-loop through the lower-level array and print the schedule as it has to be.

This does not work with numbers as the names of the members and also not with "v >= n".

byelessSchedule

        $schedule->byelessSchedule();

Returns a reference to an array of arrays. The arrays are the same as returned by "wholeSchedule" without the "Byes," so you can iterate through them and print the schedule as it has to be.

This does not work with numbers as the names of the members and also not with "v >= n".

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 $member's 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.

hasBye

        $schedule->hasBye($index)

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

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. Don't 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.