Class TwoRoundRunoff<C>

Readonlycandidates

Static ReadonlyisRandom

matrix

• get matrix(): Matrix<C>

  Return a matrix of duels from all the ballots

  Returns Matrix<C>

iteratedRanking

• iteratedRanking(): C[][]

  Ranking built by repeated wins instead of the method's own full ranking: run the method, record the winning tier, then re-run it restricted to the remaining candidates for the next place, and so on.

  Differs from ranking() whenever the method's full ranking disagrees with how it ranks subsets — e.g. instant runoff orders losers by elimination time, while iterating re-elects a winner at every place.

  Returns C[][]

ranking

• ranking(): C[][]

  Result of the vote. The first item lists the winners of the vote.

  For example this ranking means that Bear wins, Sheep is second and Lion third [ [ 'Bear' ], [ 'Sheep' ], [ 'Lion' ] ]

  Returns C[][]

restrict

• restrict(candidates: readonly C[]): this

  Return a new instance of the same method restricted to a subset of candidates: the same method, run afresh on the ballots as given, as if only candidates ran. A ballot ranking none of them is blank.

  Parameters

  • candidates: readonly C[]

  Returns this

rounds

• rounds(): Round<C, undefined>[]

  Each round, for methods that eliminate.

  Returns Round<C, undefined>[]

Staticwith

• with<T extends MethodCtor<string>>(
      this: T,
      options: PropsOf<T> & {
          label?: string;
          mode?: "restricted" | "full" | "recursive";
      },
  ): readonly [
      T,
      PropsOf<T> & { label?: string; mode?: "restricted" | "full" | "recursive" },
  ]

  The method as an Election method, with options for its constructor and mode or label.

  Type Parameters

  • T extends MethodCtor<string>

  Parameters

  • this: T
  • options: PropsOf<T> & { label?: string; mode?: "restricted" | "full" | "recursive" }

    • Optionallabel?: string

      Name in traces (TieBreakStep.name, StepResult.name) instead of the method's label.

    • Optionalmode?: "restricted" | "full" | "recursive"

      Which candidates the method ranks a tie among: the tied ones ('restricted', default), everyone ('full'), or the tied ones, then those of each tie that leaves, until none splits ('recursive').

  Returns readonly [
      T,
      PropsOf<T> & { label?: string; mode?: "restricted" | "full" | "recursive" },
  ]

  Example

  new Election({
    candidates,
    ballots,
    methods: [Copeland, Borda.with({ mode: 'full' })],
  })
  Copy