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).
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 formsOther 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] .
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.