Most methods that have been rung and named at stages major and above have been rung at even stages, with Plain Bob lead ends and lead heads, without jump changes, and with the usual palindromic symmetry. For major, and at higher stages if the tenors are kept together, the false course heads of such methods are traditionally partitioned into named sets all of whose elements must occur together in such methods. These are traditionally called “false course head groups” (FCHs), although they are not what mathemeticians usually mean by the word “group”. Further information is available from a variety of sources, including Appendix B of Peter Niblett’s XML format documentation.
Roan provides a collection of fch-group
objects that represent these FCH groups.
Each is intended to be an singleton object, and under normal circumstances new instances
should not be created. They can thus be compared using eq
, if desired. The
fch-group
s for major are distinct from those for higher stages, though their
contents are closely related.
An fch-group
can be retrieved using the fch-group
function. The first
argument to this function can be either a row
or a string. If a row
the fch-group
that contains that row is returned. If a string the fch-group
with that name is returned. In this latter case two further, optional arguments can be
used to state that the group for higher stages is desired, and whether the one with just
in course or just out of course false course heads is desired; for major all the
fch-group
s contain both in and out of course elements.
The fch-group-name
, fch-group-parity
and fch-group-elements
functions
can be used to retrieve the name, parity and elements of a fch-group
. The
method-falseness
function calculates the false course heads of non-differential,
treble dominated methods at even stages major and above, and for those with the usual
palindromic symmetry and Plain Bob lead heads and lead ends, also returns the relevant
fch-group
s. The fch-groups-string
function can be used to format a
collection of fch-group
names in a traditional, compact manner.
It is possible to extend the usual FCH groups to methods with non-Plain Bob lead heads. However, Roan currently provides no support for this.
Describes a false course head group, including its name, parity if for even stages above
major, and a list of the course heads it contains. The parity is nil
for major
fch-group
s, and one of the keywords :in-course
or :out-of-course
for
higher stages. The elements of a major fch-group
are major row
s while those
for a higher stage fch-group
are royal row
s.
Returns an fch-group
described by the provided arguments. The item can be
either a row
or a string designator.
If item is a row
the fch-group
that contains that row among its
elements is returned. If it is not at an even stage, major or above, or if it is at an
even stage royal or above but with any of the bells conventionally called the seven (and
represented in Roan by the integer 6
) or higher out of their rounds positions,
nil
is returned. If item is a row
at an even stage maximus or above,
with the back bells in their home positions, it is treated as if it were the equivalent
royal row
. When item is a row
neither higher-stage nor
out-of-course may be supplied.
If item is a string designator the fch-group
that has that name is returned.
If the generalized boolean higher-stage is true a higher stage fch-group
is
returned and others a major one. In the case of higher stage groups if the generalized
boolean out-of-course is true the group with the given name containing only out of
course elements is returned, and otherwise the one with only in course elements. Both
higher-stage and out-of-course default to nil
if not supplied. If there
is no fch-group
with name item and the given properties nil
is
returned.
Signals a type-error
if item is neither a row
nor a string designator.
Signals an error if item is a row
and higher-stage or
out-of-course is supplied.
(let ((g (fch-group !2436578))) (list (fch-group-name g) (fch-group-parity g) (stage (first (fch-group-elements g))))) ⇒ ("B" nil 8) (fch-group "a1" t nil) ⇒ nil (fch-group-elements (fch-group "a1" t t)) ⇒ (!1234657890)
Returns the name, parity or elements of the fch-group
group.
The value returned by fch-group-name
is a string of length one or two. For major
groups it is always of length one, and is a letter. For higher stages if of length one it
is again a letter, and if of length two it is a letter followed by the digit ‘1’ or
the digit ‘2’. The case of letters in fch-group
names is significant.
For major fch-group
s fch-group-parity
always returns nil
. For higher
stage fch-group
s it always returns either :in-course
or
:out-of-course
.
The fch-group-elements
function returns a list of row
s, the elements of the
group. For major groups these are always major row
s, and for higher stage groups
royal rows
. The alter-stage
fucntion (see alter-stage) can be helpful
for making such row
s conform to the needs of other stages above major.
All three functions signal a type-error
if group is not a fch-group
.
Returns a string succinctly describing a set of fch-group
s, in a conventional
order. The set of fch-group
s is the union of all those contained in the arguments,
each of which should be a sequence or hash-set
, all of whose elements are
fch-group
s. The resulting string contains the names of the distinct
fch-group
s. If there are no groups nil
, rather than an empty string, is
returned.
For higher stages there are two sequences of group names in the string, separated by a
solidus (‘/’); those before the solidus are in course and those after it out of
course. For example, "B/Da1"
represents the higher course in course elements of
group B and out of course elements of groups D and a1.
The group names are presented in the conventional order. For major the groups containing in course, tenors together elements appear first, in alphabetical order; followed by those all of whose tenors together elements are out of course, in alphabetical order; finally followed by those all of whose elements are tenors parted. For higher stages the capital letter groups in each half of the string come first, in alphabetical order, followed by those with lower case names. Note that a lower case name can never appear before the solidus.
Signals a type-error
if any of the arguments are not sequences or hash-set
s,
or if any of their elements is not an fch-group
. Signals a
mixed-stage-fch-groups-error
if some of the elements are major and some are higher
stage fch-group
s.
(fch-groups-string (list (fch-group "a") (fch-group "B"))) ⇒ "Ba" (fch-groups-string #((fch-group "D" t t) (fch-group "a1" t t)) (hash-set (fch-group "B" t))) ⇒ "B/Da1" (fch-groups-string (list (fch-group "T" t nil))) ⇒ "T/" (fch-groups-string (list (fch-group "T" t t))) ⇒ "/T"
Computes the most commonly considered kinds of internal falseness of the most common
methods: those at even stages major or higher with a single hunt bell, the treble, and all
the working bells forming one cycle, that is, not differential. Falseness is only
considered with the treble fixed, as whole leads, and, for stages royal and above, with
the seventh (that is, the bell roan denotes by 6
) and above fixed. Returns three
values: a summary of the courses that are false; for methods that have Plain Bob lead ends
and lead heads and the usual palindromic symmetry, the false course head groups that are
present; and a description of the incidence of falseness.
The first value is a list of course heads, row
s that have the treble and tenors
fixed, such that the plain course is false against the courses starting with any of these
course heads. Rounds is included only if the falseness occurs between rows at two
different positions within the plain course. Course heads for major have just the
tenor (that is, the bell represented in Roan by the integer 7
) fixed, while course
heads for higher stages have all of the seventh and above (that is, bells represented in
Roan by the integers 6
and larger) fixed in their rounds positions.
If method has Plain Bob lead ends and lead heads, and the usual palindromic
symmetry, the second value returned is a list of fch-group
objects, and otherwise
the second value is nil
. Note also that for methods that are completely clean in
the context used by this function, for example plain royal methods, an empty list also
will be returned. These two cases can be disambiguated by examining the first value
returned.
There is some ambiguity in the interpretation of “A” falseness. In Roan a method is only said to have “A” falseness if its plain course is false. That is, the trivial falseness implied by a course being false against itself and against its reverse by virtue of containing exactly the same rows is not reported as “A” falseness. “A” falseness is only reported if there is some further, not-trivial falseness between rows at two different positions within the plain course.
The third value returned is a two dimensional, square array, each of the elements of that array being a possibly empty list of course heads. For element e, the list at m,n of this array, lead m of the plain course of method is false against lead n of each of the courses starting with an element of e. The leads are counted starting with zero. That is, if s is the stage of method, then 0m<s-1 and 0n<s-1.
A type-error
is signaled if method is not a method
. Signals a
parse-error
if the place notation string cannot be properly parsed as place
notation at method’s stage. If method does not have its stage or
place-notation set a no-place-notation-error
. If method is not at an even
stage major or above, does not have one hunt bell, the treble, or is differential, an
inappropriate-method-error
is signaled.
(multiple-value-bind (ignore1 groups ignore2) (method-falseness (method :stage 8 :place-notation "x34x4.5x5.36x34x3.2x6.3,8")) (declare (ignore ignore1 ignore2) (fch-groups-string groups)) ⇒ "BDacZ" (fch-groups-string (second (multiple-value-list (method-falseness (lookup-method "Zorin Surprise" 10))))) ⇒ "T/BDa1c"