kana2romaji

    use Lingua::JA::Moji 'kana2romaji';

    $romaji = kana2romaji ("うれしいこども");
    # $romaji = 'uresîkodomo'

Convert kana to a romanized form.

An optional second argument, a hash reference, controls the style of conversion.

    use utf8;
    $romaji = kana2romaji ("しんぶん", {style => "hepburn"});
    # $romaji = "shimbun"

The options are

style

The style of romanization. The default style of romanization is "Nippon-shiki". The user can set the conversion style to "hepburn" or "passport" or "kunrei" or "common". If Hepburn is selected, then the following option "use_m" is set to "true", and the "ve_type" is set to "macron". The "common" style is the same as the Hepburn style, but it does things like changing "ジェット" to "jetto" rather than ignoring the small vowel.

Possible styles are as follows:

use_m

If this is true, syllabic ns (ん) which come before "b" or "p" sounds, such as the first "n" in "shinbun" (しんぶん, newspaper) will be converted into "m" rather than "n".

ve_type

The "ve_type" option controls how long vowels are written. The default is to use circumflexes to represent long vowels.

wo

     kana2romaji ("ちりぬるを", { wo => 1 });
    

If "wo" is set to a true value, "を" becomes "wo", otherwise it becomes "o".

romaji2kana

    use Lingua::JA::Moji 'romaji2kana';

    $kana = romaji2kana ('yamaguti');
    # $kana = 'ヤマグチ'

Convert romanized Japanese to katakana. The romanization is highly liberal and will attempt to convert any romanization it sees into katakana. The romanization is based on the behaviour of the Microsoft IME (input method editor). To convert romanized Japanese into hiragana, use "romaji2hiragana".

An optional second argument to the function contains options in the form of a hash reference,

     $kana = romaji2kana ($romaji, {wapuro => 1});

Use an option "wapuro => 1" to convert long vowels into the equivalent kana rather than "chouon".

     $kana = romaji2kana ($romaji, {ime => 1});

Use the "ime => 1" option to approximate the behaviour of an IME. For example, input "gumma" becomes グッマ and input "onnna" becomes オンナ. Passport romaji ("Ohshimizu") is disallowed if this option is switched on.

romaji2hiragana

    use Lingua::JA::Moji 'romaji2hiragana';

    $hiragana = romaji2hiragana ('babubo');
    # $hiragana = 'ばぶぼ'

Convert romanized Japanese into hiragana. This takes the same options as "romaji2kana". It also switches on the "wapuro" option, which uses long vowels with a kana rather than a "chouon".

romaji_styles

    use Lingua::JA::Moji 'romaji_styles';

    my @styles = romaji_styles ();
    # Returns a true value
    romaji_styles ("hepburn");
    # Returns the undefined value
    romaji_styles ("frogs");

Given an argument, this return a true value if it is a known style of romanization.

Without an argument, it returns a list of possible styles, as an array of hash references, with each hash reference containing the short name under the key "abbrev" and the full name under the key "full_name".

is_voiced

    use Lingua::JA::Moji 'is_voiced';

    if (is_voiced ('が')) {
         print "が is voiced.\n";
    }

Given a kana or romaji input, "is_voiced" returns a true value if the sound is a voiced sound like a, za, ga, etc. and the undefined value if not.

is_romaji

    use Lingua::JA::Moji 'is_romaji';

    # The following line returns "undef"
    is_romaji ("abcdefg");
    # The following line returns a defined value
    is_romaji ('loyehye');
    # The following line returns a defined value
    is_romaji ("atarimae");

This detects whether a string of alphabetical characters, which may also include characters with macrons or circumflexes, "looks like" romanized Japanese. If the test is successful, it returns a true value, and if the test is unsuccessful, it returns a false value. If the string is empty, it returns a false value.

This works by converting the string to kana via "romaji2kana" and seeing if it converts cleanly or not.

is_romaji_strict

    use Lingua::JA::Moji 'is_romaji_strict';

    # The following line returns "undef"
    is_romaji_strict ("abcdefg");
    # The following line returns "undef"
    is_romaji_strict ('loyehye');
    # The following line returns a defined value
    is_romaji_strict ("atarimae");

This detects whether a string of alphabetical characters, which may also include characters with macrons or circumflexes, "looks like" romanized Japanese. If the test is successful, it returns a true value, and if the test is unsuccessful, it returns a false value. If the string is empty, it returns a false value.

This test is much stricter than "is_romaji". It insists that the word does not contain constructions which may be valid as inputs to an IME, but which do not look like Japanese words.

normalize_romaji

    use Lingua::JA::Moji 'normalize_romaji';

    $normalized = normalize_romaji ('tsumuji');

"normalize_romaji" converts romanized Japanese to a canonical form, which is based on the Nippon-shiki romanization, but without representing long vowels using a circumflex. In the canonical form, sokuon (っ) characters are converted into the string "xtu". If there is kana in the input string, this will also be converted to romaji.

"normalize_romaji" is for comparing two Japanese words which may be represented in different ways, for example in different romanization systems, to see if they refer to the same word despite the difference in writing. It does not provide a standardized or officially-sanctioned form of romanization.

hira2kata

    use Lingua::JA::Moji 'hira2kata';

    $katakana = hira2kata ('ひらがな');
    # $katakana = 'ヒラガナ'

"hira2kata" converts hiragana into katakana. The input may be a single string or a list of strings. If the input is a list, it converts each element of the list, and in list context it returns a list of the converted inputs. In scalar context it returns a concatenation of the strings.

    my @katakana = hira2kata (@hiragana);

This does not convert "chouon" signs.

kata2hira

    use Lingua::JA::Moji 'kata2hira';

    $hiragana = kata2hira ('カキクケコ');
    # $hiragana = 'かきくけこ'

"kata2hira" converts full-width katakana into hiragana. If the input is a list, it converts each element of the list, and in list context, returns a list of the converted inputs, otherwise it returns a concatenation of the strings.

    my @hiragana = hira2kata (@katakana);

This function does not convert "chouon" signs into long vowels. It also does not convert half-width katakana into hiragana.

kana2katakana

    use Lingua::JA::Moji 'kana2katakana';

This converts any of katakana, "halfwidth katakana", circled katakana and hiragana to full width katakana.

kana_to_large

    use Lingua::JA::Moji 'kana_to_large';

    $large = kana_to_large ('ぁあぃい');
    # $large = 'ああいい'

Convert small-sized kana such as 「ぁ」 into full-sized kana such as 「あ」.

nigori_first

    use Lingua::JA::Moji 'nigori_first';

    my @list = (qw/カン スウ ハツ オオ/);
    nigori_first (\@list);
    # Now @list = (qw/カン スウ ハツ オオ ガン ズウ バツ パツ/);

Given a list of kana, add all the possible versions of the words with the first kana with either a dakuten or a handakuten added.

InHankakuKatakana

    use Lingua::JA::Moji 'InHankakuKatakana';

    use utf8;
    if ('ｱ' =~ /\p{InHankakuKatakana}/) {
        print "ｱ is half-width katakana\n";
    }

"InHankakuKatakana" is a character class for use in regular expressions with "\p" which can validate "halfwidth katakana".

kana2hw

    use Lingua::JA::Moji 'kana2hw';

    $half_width = kana2hw ('あいウカキぎょう。');
    # $half_width = 'ｱｲｳｶｷｷﾞｮｳ｡'

"kana2hw" converts hiragana, katakana, and fullwidth Japanese punctuation to "halfwidth katakana" and halfwidth punctuation. Its function is similar to the Emacs command "japanese-hankaku-region". For the opposite function, see hw2katakana. See also "katakana2hw" for a function which only converts katakana.

hw2katakana

    use Lingua::JA::Moji 'hw2katakana';

    $full_width = hw2katakana ('ｱｲｳｶｷｷﾞｮｳ｡');
    # $full_width = 'アイウカキギョウ。'

"hw2katakana" converts "halfwidth katakana" and halfwidth Japanese punctuation to fullwidth katakana and fullwidth punctuation. Its function is similar to the Emacs command "japanese-zenkaku-region". For the opposite function, see kana2hw.

katakana2hw

    use Lingua::JA::Moji 'katakana2hw';

    $hw = katakana2hw ("あいうえおアイウエオ");
    # $hw = 'あいうえおｱｲｳｴｵ'

This converts katakana to "halfwidth katakana", leaving hiragana unchanged. See also "kana2hw".

is_kana

    use Lingua::JA::Moji 'is_kana';

This function returns a true value if its argument is a string of kana, or an undefined value if not. The input cannot contain punctuation or "chouon".

is_hiragana

    use Lingua::JA::Moji 'is_hiragana';

This function returns a true value if its argument is a string of hiragana, and an undefined value if not. The entire string from beginning to end must all be kana for this to return true. The kana cannot include punctuation marks or "chouon".

kana_order

    use Lingua::JA::Moji 'kana_order';

    $kana_order = kana_order ();

Returns an array reference containing an ordering of the kana. This is useful for looping over the kana or sorting.

katakana2syllable

    use Lingua::JA::Moji 'katakana2syllable';

    $syllables = katakana2syllable ('ソーシャルブックマークサービス');

This breaks the given string into syllables. If the string is broken up character by character, it becomes 'ソ', 'ー', 'シ', 'ャ', 'ル'. This breaks the string up into meaningful syllables, so that $syllables becomes 'ソー', 'シャ', 'ル'.

InKana

    use Lingua::JA::Moji 'InKana';

    $is_kana = ('あいうえお' =~ /^\p{InKana}+$/);
    # $is_kana = '1'

A character class for use in regular expressions which matches all kana characters. This class catches meaningful combinations of hiragana, katakana, halfwidth katakana, circled katakana, and katakana combined words.

This is a combination of the existing Perl character classes "Katakana", "InKatakana", and "InHiragana", minus unassigned characters, plus the "halfwidth katakana prolonged sound mark" (U+FF70) <ｰ> (chouon), the "halfwidth katakana voiced sound mark" (U+FF9E) <ﾞ> (dakuten) and the "halfwidth katakana semivoiced sound mark" (U+FF9F) <ﾟ> (handakuten), minus '・', Unicode 30FB, "KATAKANA MIDDLE DOT". It is somewhat like the following:

    qr/\p{Katakana}|\p{InKatakana}|\p{InHiragana}|ｰ|ﾞ|ﾟ>/

except that the unassigned points which are matched by "\p{Katakana}" are not matched and KATAKANA MIDDLE DOT is not matched.

square2katakana

    use Lingua::JA::Moji 'square2katakana';

    $kata = square2katakana ('㌆');
    # $kata = 'ウォン'

Convert a square katakana box into its components.

katakana2square

    use Lingua::JA::Moji 'katakana2square';

    $sq = katakana2square ('アイウエオウォン');
    # $sq = 'アイウエオ㌆'

Convert katakana into a square thing if possible.

InWideAscii

    use Lingua::JA::Moji 'InWideAscii';

    use utf8;
    if ('Ａ' =~ /\p{InWideAscii}/) {
        print "Ａ is wide ascii\n";
    }

This is a character class for use with \p which matches "wide ASCII"

wide2ascii

    use Lingua::JA::Moji 'wide2ascii';

    $ascii = wide2ascii ('ａｂＣＥ０１９');
    # $ascii = 'abCE019'

Convert "wide ASCII" into ASCII.

ascii2wide

    use Lingua::JA::Moji 'ascii2wide';

    $wide = ascii2wide ('abCE019');
    # $wide = 'ａｂＣＥ０１９'

Convert ASCII into "wide ASCII".

kana2morse

    use Lingua::JA::Moji 'kana2morse';

    $morse = kana2morse ('しょっちゅう');
    # $morse = '--.-. -- .--. ..-. -..-- ..-'

Convert Japanese kana into Morse code. Japanese morse code does not have any way of representing small kana characters, so converting to and then from morse code will result in しょっちゅう becoming シヨツチユウ.

morse2kana

    use Lingua::JA::Moji 'morse2kana';

    $kana = morse2kana ('--.-. -- .--. ..-. -..-- ..-');
    # $kana = 'シヨツチユウ'

Convert Japanese Morse code into kana. Each Morse code element must be separated by whitespace from the next one.

Bugs

This has not been extensively tested.

kana2braille

    use Lingua::JA::Moji 'kana2braille';

This converts kana into the equivalent Japanese braille (tenji) forms.

Bugs

This has not been extensively tested. This is not an adequate Japanese braille convertor. Creating Japanese braille requires breaking Japanese sentences up into individual words, but this does not attempt to do that. People who are interested in building a Perl braille convertor could start here.

braille2kana

    use Lingua::JA::Moji 'braille2kana';

Converts Japanese braille (tenji) into the equivalent katakana.

kana2circled

    use Lingua::JA::Moji 'kana2circled';

    $circled = kana2circled ('あいうえお');
    # $circled = '㋐㋑㋒㋓㋔'

This function converts kana into the "circled katakana" of Unicode, which have code points from 32D0 to 32FE. See also "circled2kana".

There is no circled form of the ン kana, so this is left untouched.

circled2kana

    use Lingua::JA::Moji 'circled2kana';

    $kana = circled2kana ('㋐㋑㋒㋓㋔');
    # $kana = 'アイウエオ'

This function converts the "circled katakana" of Unicode into full-width katakana. See also "kana2circled".

new2old_kanji

    use Lingua::JA::Moji 'new2old_kanji';

    $old = new2old_kanji ('三国 連太郎');
    # $old = '三國 連太郎'

Convert new-style (post-1949) kanji (Chinese characters) into old-style (pre-1949) kanji.

Bugs

The list of characters in this convertor may not contain every pair of old/new kanji.

It will not correctly convert 弁 since this has three different equivalents in the old system.

old2new_kanji

    use Lingua::JA::Moji 'old2new_kanji';

    $new = old2new_kanji ('櫻井');
    # $new = '桜井'

Convert old-style (pre-1949) kanji (Chinese characters) into new-style (post-1949) kanji.

circled2kanji

    use Lingua::JA::Moji 'circled2kanji';

    $kanji = circled2kanji ('㊯');
    # $kanji = '協'

Convert the circled forms of kanji into their uncircled equivalents.

kanji2circled

    use Lingua::JA::Moji 'kanji2circled';

    $kanji = kanji2circled ('協嬉');
    # $kanji = '㊯嬉'

Convert the usual forms of kanji into circled equivalents, if they exist. Note that only a limited number of kanji have circled forms.

bracketed2kanji

    use Lingua::JA::Moji 'bracketed2kanji';

    $kanji = bracketed2kanji ('㈱');
    # $kanji = '株'

Convert bracketed form of kanji into unbracketed form.

kanji2bracketed

    use Lingua::JA::Moji 'kanji2bracketed';

    $kanji = kanji2bracketed ('株');
    # $kanji = '㈱'

Convert unbracketed form of kanji into bracketed form, if it exists.

kana2cyrillic

    use Lingua::JA::Moji 'kana2cyrillic';

    $cyril = kana2cyrillic ('シンブン');
    # $cyril = 'симбун'

cyrillic2katakana

    use Lingua::JA::Moji 'cyrillic2katakana';

    $kana = cyrillic2katakana ('симбун');
    # $kana = 'シンブン'

kana2hangul

    use Lingua::JA::Moji 'kana2hangul';

    $hangul = kana2hangul ('すごわざ');
    # $hangul = '스고와자'

Bugs

Doesn't deal with syllabic n

May be incorrect

This is based on a list found on the internet at <http://kajiritate-no-hangul.com/kana.html>. There is currently no proof of correctness.

Japanese kana/romanization

Data::Validate::Japanese

This contains four validators for kanji and kana, "is_hiragana", corresponding to "is_hiragana" in this module, and three more, "is_kanji", "is_katakana", and "is_h_katakana", for half-width katakana.

Lingua::JA::Kana

This contains convertors for hiragana, half width and full width katakana, and romaji. As of version 0.07 [Aug 06, 2012], the romaji conversion is less complete than this module.

Lingua::JA::Romanize::Japanese

Romanization of Japanese. The module also includes romanization of kanji via the kakasi kanji to romaji convertor, and other functions.

Lingua::JA::Romaji::Valid

Validate romanized Japanese. This module does the same thing as "is_romaji" in Lingua::JA::Moji.

Lingua::JA::Hepburn::Passport

Passport romanization, which means converting long vowels into "OH". This corresponds to "kana2romaji" in the current module using the "passport => 1" option, for example

    $romaji = kana2romaji ("かとう", {style => 'hepburn', passport => 1});
    

Lingua::JA::Fold

Full/half width conversion, collation of Japanese text.

Lingua::JA::Romaji

Romaji to kana/kana to romaji conversion.

Lingua::JA::Regular::Unicode

This includes hiragana to katakana, full width / half width, and wide ascii conversion. The strange name is due to its being an extension of Lingua::JA::Regular using Unicode-encoded strings.

Lingua::JA::NormalizeText

A huge collection of normalization functions for Japanese text. If Lingua::JA::Moji does not have it, Lingua::JA::NormalizeText may do.

Lingua::KO::Munja

This is similar to the present module for Korean.

Kana/kanji conversion

Lingua::JA::Romanize::MeCab

Romanization of Japanese language with MeCab

Text::MeCab

Lingua::JA::Romanize::Japanese

Romanization of Japanese language via kakasi.

Books

chouon

wide ASCII

Halfwidth katakana