[an error occurred while processing this directive] [an error occurred while processing this directive][an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive] (none) [an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive][an error occurred while processing this directive] [an error occurred while processing this directive][an error occurred while processing this directive] [an error occurred while processing this directive][an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive] (none) [an error occurred while processing this directive] [an error occurred while processing this directive] [an error occurred while processing this directive][an error occurred while processing this directive]
[an error occurred while processing this directive] [an error occurred while processing this directive]
Skåne Sjælland Linux User Group - http://www.sslug.dk Home   Subscribe   Mail Archive   Forum   Calendar   Search
MhonArc Date: [Date Prev] [Date Index] [Date Next]   Thread: [Date Prev] [Thread Index] [Date Next]   MhonArc

Language Info Needed for Aspell (fwd)

Jeg har netop modtaget dette dokument fra Kevin Atkinson,
hovedudvikleren på Aspell.  Det jeg specielt mener er
interessant for dansk og svensk er om vi kan finde en
fornuftig måde, man kan bruge til at formalisere reglerne
for at danne sammensatte ord.

»A ska uj å nedlægge en dæmon« -- Nordenfjordsk linuxekspert

---------- Forwarded message ----------
Date: Tue, 23 Mar 2004 15:41:10 -0500 (EST)
From: Kevin Atkinson <sslug@sslug>
To: sslug@sslug, sslug@sslug, sslug@sslug
Subject: Language Info Needed for Aspell

[Please distribute this document as widely as possible.]

GNU Aspell 0.60 should be able to support most of the Word Languages.
This includes languages languages written in Arabic and other scripts
not well supported by an existing 8-bit character set.  Eventually
Aspell should be able to support any current language not based on the
Chinese writing system.

GNU Aspell is a spell checker designed to eventually replace Ispell.
Its main feature is that it does a much better job of coming up with
possible suggestions than just about any other spell checker out there
for the English language, including Ispell and Microsoft Word.
However, starting with Aspell 0.60 is should also be the only Free (as
in Freedom) that can support most languages not written in the Latin or
Cyrillic scripts.

However I, the author of Aspell, know very little about foreign
languages (ie non-English) and what it takes to correctly spell check
them.  Thus, I need other people to educate me.

If you speak a foreign language I would appreciate if you would take
the time too look over the following material and email me with any
additional information you may have.

The first part gives a thorough analysis of the languages which Aspell
can and cannot support.  If you find any of this information is
incorrect please inform me at sslug@sslug

When Aspell 0.60 is released I would like to have dictionaries
available for as many languages as possible.

Therefore, if you know of a Free word list available for a language that
is not currently listed as having a dictionary available I would
appreciate hearing form you.  I am especially interested in working
with someone to add support for languages written in the Arabic
script.  The encoding of the Arabic is quite complicated and I want to
be sure that Aspell can correctly handle it.

I would also appreciate some help converting Ispell dictionaries to
Aspell.  So, if you would like to help convert some of the dictionaries
listed as being available for Ispell please contact me.

The second part lists languages related issues involved in correctly
spell checking a document.  If you can offer any additional insight on
any of the issues discussed, or know of any additional complications
when spell checking a given language, I would appreciate hearing from

The last part discusses why Aspell uses 8-bit characters internally
for your reading pleasure.

All of this material is also included in the Aspell 0.60 manual which
you can find at http://aspell.net/devel-doc/man.

Languages Which Aspell can Support

Even though Aspell will remain 8-bit internally it should still be be
able to support any written languages not based on a logographic
script.  The only logographic writing system in current use are those
based on hànzi which includes Chinese, Japanese, and sometimes Korean.


Aspell 0.60 should be able to support the following languages as, to the
best of my knowledge, they all contain 220 or fewer symbols and can
thus, fit within an 8-bit character set. If an existing character set
does not exists than a new one can be invented. This is true even if the
script is not yet supported by Unicode as the private use area can be

Code   Language Name             Script            Dictionary   Gettext
                                                   Available    Translation

aa     Afar                      Latin             -            -
ab     Abkhazian                 Cyrillic          -            -
ae     Avestan                   Avestan           -            -
af     Afrikaans                 Latin             Yes          -
ak     Akan                      Latin             -            -
an     Aragonese                 Latin             -            -
ar     Arabic                    Arabic            -            -
as     Assamese                  Bengali           -            -
av     Avar                      Cyrillic          -            -
ay     Aymara                    Latin             -            -
az     Azerbaijani               Cyrillic          -            -
az                               Latin             -            -

ba     Bashkir                   Cyrillic          -            -
be     Belarusian                Cyrillic          Planned      Yes
bg     Bulgarian                 Cyrillic          Yes          -
bh     Bihari                    Devanagari        -            -
bi     Bislama                   Latin             -            -
bm     Bambara                   Latin             -            -
bn     Bengali                   Bengali           Planned      -
bo     Tibetan                   Tibetan           -            -
br     Breton                    Latin             Yes          -
bs     Bosnian                   Latin             -            -

ca     Catalan/Valencian         Latin             Yes          -
ce     Chechen                   Cyrillic          -            -
ch     Chamorro                  Latin             -            -
co     Corsican                  Latin             -            -
cr     Cree                      Latin             -            -
cs     Czech                     Latin             Yes          Yes
cu     Old Slavonic              Cyrillic          -            -
cv     Chuvash                   Cyrillic          -            -
cy     Welsh                     Latin             Yes          -

da     Danish                    Latin             Yes          -
de     German                    Latin             Yes          Yes
dv     Divehi                    Thaana            -            -
dz     Dzongkha                  Tibetan           -            -

ee     Ewe                       Latin             -            -
el     Greek                     Greek             Yes          -
en     English                   Latin             Yes          Yes
eo     Esperanto                 Latin             Yes          -
es     Spanish                   Latin             Yes          Incomplete
et     Estonian                  Latin             Planned      -
eu     Basque                    Latin             -            -

fa     Persian                   Arabic            -            -
ff     Fulah                     Latin             -            -
fi     Finnish                   Latin             Planned      -
fj     Fijian                    Latin             -            -
fo     Faroese                   Latin             Yes          -
fr     French                    Latin             Yes          Yes
fy     Frisian                   Latin             -            -

ga     Irish                     Latin             Yes          Yes
gd     Scottish Gaelic           Latin             Planned      -
gl     Gallegan                  Latin             Yes          -
gn     Guarani                   Latin             -            -
gu     Gujarati                  Gujarati          -            -
gv     Manx                      Latin             Planned      -

ha     Hausa                     Latin             -            -
he     Hebrew                    Hebrew            Planned      -
hi     Hindi                     Devanagari        -            -
ho     Hiri Motu                 Latin             -            -
hr     Croatian                  Latin             Yes          -
ht     Haitian Creole            Latin             -            -
hu     Hungarian                 Latin             Planned      -
hy     Armenian                  Armenian          -            -
hz     Herero                    Latin             -            -

ia     Interlingua (IALA)        Latin             Yes          -
id     Indonesian                Latin             Yes          -
ie     Interlingue               Latin             -            -
ig     Igbo                      Latin             -            -
ik     Inupiaq                   Latin             -            -
io     Ido                       Latin             -            -
is     Icelandic                 Latin             Yes          -
it     Italian                   Latin             Yes          -
iu     Inuktitut                 Latin             -            -

jv     Javanese                  Javanese          -            -
jv                               Latin             -            -

ka     Georgian                  Georgian          -            -
kg     Kongo                     Latin             -            -
ki     Kikuyu/Gikuyu             Latin             -            -
kj     Kwanyama                  Latin             -            -
kk     Kazakh                    Cyrillic          -            -
kl     Kalaallisut/Greenlandic   Latin             -            -
kn     Kannada                   Kannada           -            -
ko     Korean                    Hangeul           -            -
kr     Kanuri                    Latin             -            -
ks     Kashmiri                  Arabic            -            -
ks                               Devanagari        -            -
ku     Kurdish                   Arabic            -            -
ku                               Cyrillic          -            -
ku                               Latin             -            -
kv     Komi                      Cyrillic          -            -
kw     Cornish                   Latin             -            -
ky     Kirghiz                   Cyrillic          -            -
ky                               Latin             -            -

la     Latin                     Latin             -            -
lb     Luxembourgish             Latin             Planned      -
lg     Ganda                     Latin             -            -
li     Limburgan                 Latin             -            -
ln     Lingala                   Latin             -            -
lo     Lao                       Lao               -            -
lt     Lithuanian                Latin             Planned      -
lu     Luba-Katanga              Latin             -            -
lv     Latvian                   Latin             -            -

mg     Malagasy                  Latin             -            -
mh     Marshallese               Latin             -            -
mi     Maori                     Latin             Yes          -
mk     Makasar                   Lontara/Makasar   -            -
ml     Malayalam                 Latin             -            -
ml                               Malayalam         -            -
mn     Mongolian                 Cyrillic          -            -
mn                               Mongolian         -            -
mo     Moldavian                 Cyrillic          -            -
mr     Marathi                   Devanagari        -            -
ms     Malay                     Latin             Yes          -
mt     Maltese                   Latin             Planned      -
my     Burmese                   Myanmar           -            -

na     Nauruan                   Latin             -            -
nb     Norwegian Bokmal          Latin             Yes          -
nd     North Ndebele             Latin             -            -
ne     Nepali                    Devanagari        -            -
ng     Ndonga                    Latin             -            -
nl     Dutch                     Latin             Yes          Yes
nn     Norwegian Nynorsk         Latin             Yes          -
nr     South Ndebele             Latin             -            -
nv     Navajo                    Latin             -            -
ny     Nyanja                    Latin             -            -

oc     Occitan/Provencal         Latin             -            -
or     Oriya                     Oriya             -            -
os     Ossetic                   Cyrillic          -            -

pa     Punjabi                   Gurmukhi          -            -
pi     Pali                      Devanagari        -            -
pi                               Sinhala           -            -
pl     Polish                    Latin             Yes          -
ps     Pushto                    Arabic            -            -
pt     Portuguese                Latin             Yes          Yes

qu     Quechua                   Latin             -            -

rm     Raeto-Romance             Latin             -            -
rn     Rundi                     Latin             -            -
ro     Romanian                  Latin             Yes          Yes
ru     Russian                   Cyrillic          Yes          Yes
rw     Kinyarwanda               Latin             -            -

sa     Sanskrit                  Devanagari        -            -
sc     Sardinian                 Latin             -            -
sd     Sindhi                    Arabic            -            -
se     Northern Sami             Latin             -            -
sg     Sango                     Latin             -            -
si     Sinhalese                 Sinhala           -            -
sk     Slovak                    Latin             Yes          -
sl     Slovenian                 Latin             Yes          -
sm     Samoan                    Latin             -            -
sn     Shona                     Latin             -            -
so     Somali                    Latin             -            -
sq     Albanian                  Latin             Planned      -
sr     Serbian                   Cyrillic          -            Yes
sr                               Latin             -            -
ss     Swati                     Latin             -            -
st     Southern Sotho            Latin             -            -
su     Sundanese                 Latin             -            -
sv     Swedish                   Latin             Yes          -
sw     Swahili                   Latin             Planned      -

ta     Tamil                     Tamil             Planned      -
te     Telugu                    Telugu            -            -
tg     Tajik                     Latin             -            -
tk     Turkmen                   Latin             -            -
tl     Tagalog                   Latin             -            -
tl                               Tagalog           -            -
tn     Tswana                    Latin             -            -
to     Tonga                     Latin             -            -
tr     Turkish                   Latin             -            -
ts     Tsonga                    Latin             -            -
tt     Tatar                     Cyrillic          -            -
tw     Twi                       Latin             -            -
ty     Tahitian                  Latin             -            -

ug     Uighur                    Arabic            -            -
ug                               Cyrillic          -            -
ug                               Latin             -            -
uk     Ukrainian                 Cyrillic          Yes          -
ur     Urdu                      Arabic            -            -
uz     Uzbek                     Cyrillic          -            -
uz                               Latin             -            -

ve     Venda                     Latin             -            -
vi     Vietnamese                Latin             -            -
vo     Volapuk                   Latin             -            -

wa     Walloon                   Latin             Planned      Incomplete
wo     Wolof                     Latin             -            -

xh     Xhosa                     Latin             -            -

yi     Yiddish                   Hebrew            -            -
yo     Yoruba                    Latin             -            -

za     Zhuang                    Latin             -            -
zu     Zulu                      Latin             Planned      -

Notes on Latin Languages

Any word that can be written using on of the Latin ISO-8859 character
sets (ISO-8859-1,2,3,4,9,10,13,14,15,16) can be written, in decomposed
form, using the ASCII characters, the 23 additional letters:


   and the 14 modifiers:


   Which is a total of 37 additional Unicode code points.

   All ISO-8859 character leaves the characters 0x00 - 0x19 and 0x80 -
0x99 unmapped as they are generally used as control characters.  Of
those, 0x02 - 0x19 and 0x80 - 0x99 may be mapped to anything in Aspell.
This is a total of 62 characters which can be remapped in any ISO-8859
character set.  Thus, by remapping 37 of the 62 characters to the
previously specifed Unicode code-points, any modified ISO-8859 character
set can be used for any Latin languages covered by ISO-8859.  Of course
decomposing every single accented character wastes a lot of space, so
only characters that can be not be represented in the precomposed form
should be broken up.  By using this trick it is possible to store
foreign words in the correctly accented form in the dictionary even if
the precomposed character is not in the current character set.

   Any letter in the Unicode range U+0000 - U+0249, U+1E00..U+1EFF
(Basic Latin, Latin-1 Supplement, Latin Extended-A, Latin Extended-B,
and Latin Extended Additional) can be represented using around 175
basic letters, and 25 modifiers which is less than 220 and can thus fit
in an Aspell 8-bit character set.  Since this unicode range covers any
possible Latin language this special character set can be used to
reperesnt any word written using the Latin script if so desired.


Koren in generally written in hangeul or a mixture of hanja and hangeul.
Aspell should be able to spell check the hangeul part of the writing.
In Hangeul letters individual letters, known as jamo, are grouped
together in syllable blocks.  Unicode provided code points for both jamo
and the combined syllable block.  The syllable blocks will need to be
decomposed into jamo in order for Aspell to spell check it.


Syllabic languages use a separate symbol for each syllable of the
language.  Since most of them have more than 240 distinct characters
Aspell can not support them as is.  However, all hope is not lost as
Aspell will most likely be able to support them in the future.

Code   Language Name   Script
am     Amharic         Ethiopic
cr     Cree            Canadian Syllabics
ii     Sichuan Yi      Yi
iu     Inuktitut       Canadian Syllabics
oj     Ojibwa          Ojibwe
om     Oromo           Ethiopic
ti     Tigrinya        Ethiopic

The Ethiopic Syllabary

Even though the Ethiopic script has more than 220 distinct characters
with a little work Aspell can still handle it.  The idea is to split
each character into two parts based on the matrix representation.  The
first 3 bits will be the first part and could be mapped to `10000???'.
The next 6 bits will be the second part and could be mapped to
`11??????'.  The combined character will then be mapped with the upper
bits coming first.  Thus each Ethiopic syllabary will have the form
`11?????? 10000???'.  By mapping the first and second parts to separate
8-bit characters it is easy to tell which part represents the consonant
and which part represents the vowel of the syllabary.  This encoding of
the syllabary is far more useful to Aspell than if they were stored in
UTF-8 or UTF-16.  In fact, the exiting suggestion strategy of Aspell
will work well with this encoding with out any additional
modifications.  However, additional improvements may be possible by
taking advantage of the consonant-vowel structure of this encoding.

   In fact, the split consonant-vowel representation may prove to be so
useful that it may be beneficial to encode other syllabary in this
fashion, even if they are less than 220 of them.

   The code to break up a syllabary into the consonant-vowel parts does
not exists as of Aspell 0.60.  However, it will be fairly easy to add
it as part of the Unicode normalization process once that is written.

The Yi Syllabary

A very large syllabary with 819 distince symbols.  However, like
Ethiopic, it should be possible to support this script by breaking it

The Unified Canadian Aboriginal Syllabics

Another very large syllabary.

The Ojibwe Syllabary

With only 120 distinct symbols, Aspell can actually support this one as
is.  However, as previously mentioned, it may be beneficial to break it
up into the consonant-vowel representation anyway.


These languages, when written in the given script, are currently
unsupported by Aspell for one reason or another.

Code   Language Name   Script
ja     Japanese        Japanese
km     Khmer           Khmer
ko     Korean          Hanja + Hangeul
pi     Pali            Thai
th     Thai            Thai
zh     Chinese         Hanja

The Thai and Khmer Scripts

The Thai and Khmer scripts presents a different problem for Aspell.  The
problem is not that there are more than 220 unique symbols, but that
there are no spaces between words.  This means that there is no easy way
to split a sentence into individual words.  However, it is still
possible to spell check these scripts, it is just a lot more difficult.
I will be happy to work within someone who is interested in adding Thai
or Khmer support to Aspell, but it is not likely something I will do in
the foreseeable future.

Languages which use Hànzi Characters

Hànzi Characters are used to write Chinese, Japanese, Korean, and were
once used to write Vietnamese.  Each hànzi character represents a
syllable of a spoken word and also has a meaning.  Since there are
around 3,000 of them in common usage it is unlikely that Aspell will
ever be able to support spell checking languages written using hànzi.
However, I am not even sure if these languages need spell checking since
hànzi characters are generally not entered in directly.  Furthermore
even if Aspell could spell check hànzi the exiting suggestion strategy
will not work well at all, and thus a completely new strategy will need
to be developed.


Modern Japanese is written in a mixture of "hiragana", "katakana",
"kanji", and sometimes "romaji".  "Hiragana" and "katakana" are both
syllabaries unique to Japan, "kanji" is a modified form of hànzi, and
"romaji" uses the Latin alphabet.  With some work, Aspell should be
able to check the non-kanji part of Japanese text.  However, based on
my limited understanding of Japanese hiragana is often used at the end
of kanji.  Thus if Aspell was to simply separate out the hiragana from
kanji it would end up with a lot of word endings which are not proper
words and will thus be flagged as misspellings.  However, this can be
fairly easily rectified as text is tokenized into words before it is
converted into Aspell's internal encoding.  In fact, some Japanese text
is written in entirely in one script.  For example books for children
and foreigners are sometimes written entirely in hiragana.  Thus,
Aspell could prove at least somewhat useful for spell checking Japanese.

Languages Written in Multiple Scripts

Aspell should be able to check text written in the same language, but in
multiple scripts, with some work.  If the number of unique symbols in
both scripts is less than 220 than a special character set can be used
to allow both scripts to be encoding in the same dictionary.  However
this may not be the most efficient solution.  An alternate solution is
to store each script in its own dictionary and allow Aspell to chose
the correct dictionary based on which script the given word is written
in.  Aspell currently does not support this mode of spell checking
however it is something that I hope to eventually support.

Notes on Planned Dictionaries

be   Belarusian     Ispell Dictionary available
bn   Bengali        Unoffical Aspell Dictionary available
et   Estonian       Ispell Dictionary available
fi   Finnish        Ispell Dictionary available
gd   Scottish       Ispell Dictionary available.
     Gaelic         `http://packages.debian.org/unstable/text/igaelic'
gv   Manx           Ispell Dictionary available.
he   Hebrew         Ispell Dictionary available
hu   Hungarian      MySpell dictionary expanded to over 500 MB.  Will add
                    once affix support is worked into the dictionary
                    package system.
lb   Luxembourgish  MySpell dictionary planned.
lt   Lithuanian     MySpell dictionary expanded to over 500 MB.  Will add
                    once affix support is worked into the dictionary
                    package system.
mt   Maltese        Unofficial Aspell Dictionary available, but broken
                    link to source.
sw   Albanian       Ispell Dictionary available
sw   Swahili        Available at
                    `http://sourceforge.net/projects/translate'.  Offical
                    version comming soon.
ta   Tamil          Word list available at
                    Working with them to create an Aspell dictionary.
wa   Walloon        Ispell Dictionary available
zu   Zulu           Available at
                    `http://sourceforge.net/projects/translate'.  Offical
                    version comming soon.


The information in this chapter was gathered from numerous sources,

   * ISO 639-2 Registration Authority,

   * Languages and Scripts (Offical Unicode Site),

   * Omniglot - a guide to written language, `http://www.omniglot.com/'

   * Winkipedia - The Free Encyclopedia, `http://wikipedia.org/'

   * Ethnologue - Languages of the World, `http://www.ethnologue.com/'

   * World Languages - The Ultimate Language Store,

   * South African Languages Web, `http://www.languages.web.za/'

   * The Languages and Writing Systems of Africa (Global Advisor
     Newsletter), `http://www.intersolinc.com/newsletters/africa.htm'

   Special thanks goes to Era Eriksson for helping me the information in
this chapter.

Language Related Issues

Here are some language related issues that a good spell checker needs to
handle.  If you have any more information about any of these issues, or
of a new issue not discussed here, please email me at <sslug@sslug>.

German Sharp S

The German Sharp S or Eszett does not have an uppercase equivalent.
Instead when `ß' is converted to `SS'.  The conversion of `ß' to `SS'
requires a special rule, and increases the length of a word, thus
disallowing inplace case conversion.  Furthermore, my general rule of
converting all words to lowercase before looking them up in the
dictionary won't work because the conversion of `SS' to lowercase is
ambiguous; it can be `ss' or `ß'.  I do plan on dealing with this
eventually, however.

Compound Words

In some languages, such as German, it is acceptable to string two words
together, thus forming a compound word.  However, there are rules to
when this can be done.  Furthermore, it is not always sufficient to
simply concatenate the two words.  For example, sometimes a letter is
inserted between the two words.  I tried implementing support for
compound words in Aspell but it was too limiting and no one used it.
Before I try implementing it again I want to know all the issues

Context Sensitive Spelling

In some language, such as Luxembourgish, the spelling of a word depends
on which words surround it.  For example the the letter `n' at the end
of a word will disappear if it is followed by another word starting
with a certain letter such as an `s'.  However, it can probably get
more complicated than that.  I would like to know how complicated before
I attempt to implement support for context sensitive spelling.

Unicode Normalization

Because Unicode contains a large number of precomposed characters there
are multiple ways a character can be represented.  For example letter
a* can either be represented as


   By performing normalization first Aspell will only see one of these
representations.  The exact form of normalization depends on the
language.  Give the choice of

  1. Precomposed character

  2. Base letter + combining character(s)

  3. Base letter only

if the precomposed charter is in the target character set then (1), if
both the base and combing character is present than (2), otherwise (3).

Words With Spaces or other Symbols in Them

Many languages, including English, have words with non-letter symbols in
them.  For example the apostrophe.  These symbols generally appear in
the middle of a word, but they can also appear at the end, such as in an
abbreviation.  If a symbol can _only_ appear as part of a word than
Aspell can treat it as if it were a letter.

   However, the problem is most of these symbols have other uses.  For
example, the apostrophe is often used as a single quote and the
abbreviations marker is also used as a period.  Thus, Aspell can not
blindly treat them as if they were letters.

   Aspell currently handles the case where the symbol can only appear in
the middle of the word fairly well.  It simply assumes that if there is
a letter both before and after the symbol than it is part of the word.
This works most of the time but it is not fool proof.  For example,
suppose the user forgot to leave a space after the period:

       ... and the dog went up the tree.Then the cat ...

Aspell would think "tree.Then" is one word.  A better solution might be
to then try to check "tree" and "Then" separately.  But what if one of
them is not in the dictionary?  Should Aspell assume "tree.Then" is one

   The case where the symbol can appear at the beginning or end of the
word is more difficult to deal with.  The symbol may or may not
actually be part of the word.  Aspell currently handles this case by
first trying to spell check the word with the symbol and if that fails,
try it without.  The problem is, if the word is misspelled, should
Aspell assume the symbol belongs with the word or not?  Currently
Aspell assumes it does, which is not always the correct thing to do.

   Numbers in words present a different challenge to Aspell.  If Aspell
treats numbers as letters than every possible number a user might write
in a document must be specified in the dictionary.  This could be
easily be solved by having special code to assume all numbers are
correctly spelled.  But what about something like "4th".  Since the
"th" suffix can appear after any number we are left with the same
problem.  The solution would be to have a special symbol for "any

   Words with spaces in them, such as foreign phrases, are even more
trouble to deal with.  The basic problem is that when tokonizing a
string there is no good way to keep phrases together. One solution is to
use trial and error.  If a word is not in the dictionary try grouping it
with the previous or next word and see if the combined word is the
dictionary.  But what if the combined word is not, should the misspelled
word be grouped when looking for suggestions?  One solution is to also
store each part of the phrase in the dictionary, but tag it as part of a
phrase and not an independent word.

   To further complicate things, most applications that use spell
checkers are accustom to parsing the document themselves and sending it
to the spell checker a word at a time.  In order to support word with
spaces in them a more complicated interface will be required.

Notes on 8-bit Characters

There is a very good reason I use 8-bit characters in Aspell. Speed and
simplicity. While many parts of my code can fairly be easily be
converted to some sort of wide character as my code is clean. Other
parts can not be.

   One of the reasons because is many, many places I use a direct lookup
to find out various information about characters. With 8-bit characters
this is very feasible because there is only 256 of them. With 16-bit
wide characters this will waste a LOT of space. With 32-bit characters
this is just plain impossible. Converting the lookup tables to some
other form, while certainly possible, will degrade performance

   Furthermore, some of my algorithms relay on words consisting only on
a small number of distinct characters (often around 30 when case and
accents are not considered). When the possible character can consist of
any Unicode character this number because several thousand, if that. In
order for these algorithms to still be used some sort of limit will
need to be placed on the possible characters the word can contain. If I
impose that limit, I might as well use some sort of 8-bit characters
set which will automatically place the limit on what the characters can

   There is also the issue of how I should store the word lists in
memory? As a string of 32 bit wide characters. Now that is using up 4
times more memory than charters would and for languages that can fit
within an 8-bit character that is, in my view, a gross waste of memory.
So maybe I should store them is some variable width format such as
UTF-8. Unfortunately, way, way to many of may algorithms will simply
not work with variable width characters without significant
modification which will very likely degrade performance. So the
solution is to work with the characters as 32-bit wide characters and
than convert it to a shorter representation when storing them in the
lookup tables. Now than can lead to an inefficiency. I could also use
16 bit wide characters however that may not be good enough to hold all
of future versions of Unicode and it has the same problems.

   As a response to the space waste used by storing word lists in some
sort of wide format some one asked:

     Since hard drive are cheaper and cheaper, you could store
     dictionary in a usable (uncompressed) form and use it directly
     with memory mapping. Then the efficiency would directly depend on
     the disk caching method, and only the used part of the
     dictionaries would relay be loaded into memory. You would no more
     have to load plain dictionaries into main memory, you'll just want
     to compute some indexes (or something like that) after mapping.

   However, the fact of the matter is that most of the dictionary will
be read into memory anyway if it is available. If it is not available
than there would be a good deal of disk swaps. Making characters 32-bit
wide will increase the change that there are more disk swap. So the
bottom line is that it will be cheaper to convert the characters from
something like UTF-8 into some sort of wide character. I could also use
some sort of disk space lookup table such as the Berkeley Database.
However this will *definitely* degrade performance.

   The bottom line is that keeping Aspell 8-bit internally is a very
well though out decision that is not likely to change any time soon.
Fell free to challenge me on it, but, don't expect me to change my mind
unless you can bring up some point that I have not thought of before
and quite possible a patch to solve cleanly convert Aspell to Unicode
internally with out a serious performance lost OR serious memory usage


Aspell-announce mailing list

Home   Subscribe   Mail Archive   Index   Calendar   Search

Questions about the web-pages to <www_admin>. Last modified 2005-08-10, 20:54 CEST [an error occurred while processing this directive]
This page is maintained by [an error occurred while processing this directive]MHonArc [an error occurred while processing this directive] # [an error occurred while processing this directive] *