Next: , Previous: , Up: Top   [Contents][Index]

6 Internal Falseness

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-groups 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-groups 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-groups. 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.

Type: fch-group

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-groups, and one of the keywords :in-course or :out-of-course for higher stages. The elements of a major fch-group are major rows while those for a higher stage fch-group are royal rows.

Function: fch-group item &optional higher-stage out-of-course

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)
Function: fch-group-name group
Function: fch-group-parity group
Function: fch-group-elements group

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-groups fch-group-parity always returns nil. For higher stage fch-groups it always returns either :in-course or :out-of-course.

The fch-group-elements function returns a list of rows, the elements of the group. For major groups these are always major rows, and for higher stage groups royal rows. The alter-stage fucntion (see alter-stage) can be helpful for making such rows conform to the needs of other stages above major.

All three functions signal a type-error if group is not a fch-group.

Function: fch-groups-string collection &rest more-collections

Returns a string succinctly describing a set of fch-groups, in a conventional order. The set of fch-groups 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-groups. The resulting string contains the names of the distinct fch-groups. 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-sets, 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-groups.

 (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"
Function: method-falseness method

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, rows 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"

Next: , Previous: , Up: Top   [Contents][Index]