Modulo Class Ordering of Fidel

Yet another way to encode the Fidel matrix that is a unrestrained by tradition, operating systems, or economics. But is bound rigidly by, and exploits fully, a simple mathematic property woven into the Fidel lattice. We have all seen it, sometimes thought about it, but before computer interest came along it was not worth the effort to fully unravel this hidden level of order within Fidel.

At the beginning the Fidel writing system (WS) was well ordered, the first kernel had 26 letters of 7 forms each. Before long however user requirements changed as users changed and the customer base expanded. Script hackers of the time patched auxilary letters onto the end of the matrix. This was not to bad, the 26x7 matrix remained intact 8th forms and greater were at the end. Later as add-ons for Amharic reached 7 new series and extended orders grew as well, these modules were finally integrated into the kernel of new release for the WS. The same cycle has been repeated for extension made for Tigrigna (Qe), Orimiffa (De), and Bilin, Agew, and Gurage languages (Ge, Xe, etc).

So what was once a simple and regular system for a single language became the necessary patchwork quilt of systems that would serve all languages that would use Fidel. Since from speech we know the sounds in the language already, it is for most characters not a big deal to remember who has 7, 8, or 12 forms. When the problem is encountered in the composition of a new computer application, the programmer soon finds what he thought was natural is now a major issue to resolve. The problem boils down to ``if a computer can determine a letter is "ri" -how will it know it know if there is a rWa?". Recognizing the letter as "ri" in the first place, or that "ri" is the 3rd form of "r" is no simple matter either.

These issues become important when you want to transcribe or transliterate a Fidel document into another system or syllable-edit of a Fidel character. Below is a matrix that simplifies the issue of character form recognition.

Fidel-95NT WS/2

       le     lu     li     la     lE     l     lo     lWa     }  
       me     mu     mi     ma     mE     m     mo     mWa     } 
       re     ru     ri     ra     rE     r     ro     rWa     } 
       xe     xu     xi     xa     xE     x     xo     xWa     } 
       be     bu     bi     ba     bE     b     bo     bWa     } 
       ve     vu     vi     va     vE     v     vo     vWa     } 
       te     tu     ti     ta     tE     t     to     tWa       } 
       ce     cu     ci     ca     cE     c     co     cWa       } 
       ne     nu     ni     na     nE     n     no     nWa        }  Modulo 8 Zone
       Ne     Nu     Ni     Na     NE     N     No     NWa        }     (19 x 8)
       ze     zu     zi     za     zE     z     zo     zWa       } 
       Ze     Zu     Zi     Za     ZE     Z     Zo     ZWa       } 
       de     du     di     da     dE     d     do     dWa     } 
       Te     Tu     Ti     Ta     TE     T     To     TWa     } 
       Ce     Cu     Ci     Ca     CE     C     Co     CWa     } 
     __fe     fu     fi     fa     fE     f     fo     fWa     } 
See |  se     su     si     sa     sE     s     so     sWa     } 
Note|  Se     Su     Si     Sa     SE     S     So     SWa     } 
 __ |   e      u      i      a      E     I      o     e3      }
|   |  
|   |__he     hu     hi     ha     hE     h     ho     hWe     hW/u     hWi     hWa     hWE    }
|      ke     ku     ki     ka     kE     k     ko     kWe     kW/u     kWi     kWa     kWE    }
|      Ke     Ku     Ki     Ka     KE     K     Ko     KWe     KW/u     KWi     KWa     KWE     } Modulo 12 Zone
|      qe     qu     qi     qa     qE     q     qo     qWe     qW/u     qWi     qWa     qWE     }    (6 x 12)
|      Qe     Qu     Qi     Qa     QE     Q     Qo     QWe     QW/u     QWi     QWa     QWE    }
|      ge     gu     gi     ga     gE     g     go     gWe     gW/u     gWi     gWa     gWE    }
|   __
|  |  `se    `su    `si    `sa    `sE    `s    `so     }
|__|  `Se    `Su    `Si    `Sa    `SE    `S    `So     }
   |   `e     `u     `i     `a     `E    `I     `o     }
   |__`he    `hu    `hi    `ha    `hE    `h    `ho     }
       we     wu     wi     wa     wE     w     wo     }
       He     Hu     Hi     Ha     HE     H     Ho      }
       ye     yu     yi     ya     yE     y     yo       } Modulo 7 Zone
       De     Du     Di     Da     DE     D     Do      }    (11 x 7)
       je     ju     ji     ja     jE     j     jo     }
       Ge     Gu     Gi     Ga     GE     G     Go     }
       Pe     Pu     Pi     Pa     PE     P     Po     }
       pe     pu     pi     pa     pE     p     po     }

        1      2      3      4      5     6      7      8      9   }
       10     20     30     40     50    60     70     80     90    } Numbers and Punctuation
      100    10K    " "      :      ,     ;     :-     -:     ::    }   (Not a Modulo Class)
       \?    :|:     ''     <<     >>     ?                        }
It should be fairly obvious what has happened. All letters with like number of forms are grouped together. The number of orders a letter has is its ``modulo class''. For numbers and punctuation there is not as big a pay off later to putting them into as organized a group. It is convenient that numbers are together as it is for punctuation (also that all of the tens are equidistant from the ones).

Exploiting the Modulo Class Regions

Computer work with letters in the form of numbers, actually the work with everything in the form of numbers. Unlike us, computers don't have real eyes ears and other sences to know the difference between two things. So everything gets converted to numbers which the computer can compare easily. So, since we are talking about ``letters'' we need a way to talk about letters as numbers.

Lets us [ ] to mean "the address of" whatever is inside of [ and ]. For instance [le] would be 0 (computer types like to start with zero) and [me] would mean 8 using the table above. Also, lets use 'x' to be any letter in the Fidel matrix. So [x] is 0 if x = le, and [x] = 8 if we wanted x = me. For discussion it is conveneint just to use 'x' without worrying about its true identity.

Given the Fidel table above we can make it easy to tell a computer how to figure out how many syllables the letter 'x' will have. We can use ``greter than'' and ``less than'' rules to do this:

  IF   [le]  <=  [x]  <  [he]    THEN  'x' has  8 forms
  IF   [he]  <=  [x]  <  [`se]   THEN  'x' has 12 forms
  IF   [`se] <=  [x]  <  [1]     THEN  'x' has  7 forms
Other things we can find out about 'x' from where it resides in the table (what we have been calling its ``address'') are:
  IF   [se]  <=  [x]  <  [hWa]   THEN  'x' has a homophonic cousin a fixed
                                           distance away.
  IF   [1]   <=  [x]             THEN  'x' is not a letter
  IF   [1]   <=  [x]  <  [" "]   THEN  'x' is a number
  IF   [" "] <=  [x]             THEN  'x' is a punctuation
So when is it important to know how many forms a letter has? One example is for an editing feature to change only the order of a letter and not the whole letter. Lets say the cursor is over rE and you want to change it to ri. This can be done by typing only 'i' or maybe Control-'i' without complicated math. A sample calculation:
    Let 'x' be any 5th order letter that has 7 forms and we want to
    adjust to the 3rd form.

       new_order = 'i' (`sals) = 2         ( remember we start at zero! )

       IF  [`se] <= [x] < [1]  THEN  forms = 7

       order = ( [x] - [`se] ) % forms = 4

       'x' = 'x' + (new_order - order)
           = 'x' + (2 - 4)
Here, the % symbol is the modulus operator which is available in some form in any programming or macro language (sometimes given the name ``mod''). These few lines are enough to adjust any 5th order letter to the 2nd -and the beauty is that we didn't even have to know what letter it was!

If we did want to know what 'x' was a way to find out would be:

       IF  [`se] <= [x] < [1]  THEN  forms = 7

       order = ( [x] - [`se] ) % forms = 4

       iam = [x] - order
This guarantees that `iam' will be a first (or g`Iz) form letter. The `iam' variable will have to be checked in a table to see that it migt be ``ye'' for instance. The advantage is that our lookup table has only 33 letters or so instead of more than 300. This saves memory and searching time. We could keep in this table only the Roman letter 'y' [ye] . Since we know `order' a second table can tell us: order = 1 = 'e' , order = 2 = 'u' , etc. Then transcription is made simple by printing Table1[iam] and Table2[order] .


The modulo class ordering of Fidel was created out of necessity for a SERA transcriber for GohaTibeb a DOS WordPerfect add on package for Fidel. The WP macro language had limited logic capabilities and so Fidel had to be ordered logically. Another consideration for WP was that address space was minimal and so no ``gaps'' could be afforded within the matrix. Mule uses the same ordering system (a modification of the above) and it is found in Admas X-11 fonts.

An obvious flaw in the above ordering is that it makes for an unnatural sorting order. Sorters usually rely on character addresses. The modulo ordering is then NOT recommended as an address encoding system for Fidel. The merits of the ordering is purely its algorthmic fascilitations and as such should be used only for internal modeling of Fidel by applications.