Esempio n. 1
0
        protected override string convertHundreds(int hundreds, int tens, int classOfNumber)
        {
            result = "";
            switch (!Number.isNull(classOfNumber))
            {
            case true:
                switch (hundreds != 0)    //hundreds
                {
                case true:
                    result += checkOnes(hundreds) + Ordinal.getClassName(0);
                    switch (classOfNumber == 0 && tens == 0)
                    {
                    case true:
                        result += "th";
                        break;
                    }
                    break;
                }
                switch (tens > 19)    //Tens
                {
                case true:
                    result += Ordinal.getTens(tens / 10);
                    switch (classOfNumber == 0)         // if last hundred
                    {
                    case true:
                        switch (tens % 10 != 0)
                        {
                        case true:
                            result += "y";
                            switch (tens % 10 < 5)
                            {
                            case true:
                                result += Ordinal.getLastOnes(tens % 10);
                                break;

                            case false:
                                result += Ordinal.getOnes(tens % 10) + "th";
                                break;
                            }
                            break;

                        case false:
                            result += "ieth";
                            break;
                        }
                        break;

                    case false:
                        result += "y";
                        result += checkOnes(tens % 10);
                        break;
                    }
                    break;

                case false:
                    switch (classOfNumber == 0)         // if last hundred
                    {
                    case true:
                        switch (tens < 5)
                        {
                        case true:
                            result += Ordinal.getLastOnes(tens);
                            break;

                        case false:
                            result += Ordinal.getOnes(tens) + "th";
                            break;
                        }
                        break;

                    case false:
                        result += checkOnes(tens);
                        break;
                    }
                    break;
                }
                switch (classOfNumber > 0)     // Names of number classes
                {
                case true:
                    result += Ordinal.getClassName(classOfNumber);
                    switch (Number.getLastClass() == classOfNumber)
                    {
                    case true:
                        result += "th";
                        break;
                    }
                    break;
                }
                break;
            }
            return(result);
        }
Esempio n. 2
0
        protected override string convertHundreds(int hundreds, int tens, int classOfNumber)
        {
            result = "";
            switch (!Number.isNull(classOfNumber))
            {
            case true:
                switch (classOfNumber == 0)
                {
                case true:
                    lastHundred(hundreds, tens);
                    break;

                case false:
                    switch (classOfNumber == Number.getLastClass())
                    {
                    case true:             // якщо клас числа є останнім (Складні порядові числівники, що закінчуються на "тисячний, мільйонний, мільярдний, трильйонний" пишуться разом та всі частини відмінюються)
                        switch (hundreds)
                        {
                        case 0:
                            break;

                        case 1:
                            result += "ста";
                            break;

                        default:
                            onesInLastThousandsToOrdinal(hundreds);
                            result += "сот";
                            break;
                        }
                        switch (tens > 19)
                        {
                        case true:
                            switch (tens / 10)
                            {
                            case 4:
                                result += Ordinal.getTens(tens / 10) + "а";
                                break;

                            case 9:
                                result += Ordinal.getTens(tens / 10) + "о";
                                break;

                            default:
                                result += Ordinal.getTens(tens / 10) + "и";
                                break;
                            }
                            onesInLastThousandsToOrdinal(tens % 10);                 // винесено у метод для уникнення повторення
                            break;

                        case false:
                            switch (tens)
                            {
                            case 1:
                                break;

                            default:
                                onesInLastThousandsToOrdinal(tens);                     // винесено у метод для уникнення повторення
                                break;
                            }
                            break;
                        }
                        result += Ordinal.getClassName(classOfNumber) + "ний";
                        break;

                    case false:             // Не останній класс числа
                        hundredsToOrdinal(hundreds);
                        tensToOrdinal(tens / 10);
                        switch (classOfNumber)             // для корректного роду числівників
                        {
                        case 1:
                            switch (tens > 19 || tens < 4)
                            {
                            case true:                     // одна тисяча, дві-три-чотири тисячі... тисяч
                                switch (tens % 10)
                                {
                                case 1:
                                    result += Ordinal.getOnes(tens % 10) + "нa " + Ordinal.getClassName(classOfNumber) + "а ";
                                    break;

                                case 2:
                                    result += Ordinal.getOnes(tens % 10) + "і " + Ordinal.getClassName(classOfNumber) + "і ";
                                    break;

                                case 3:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "і ";
                                    break;

                                case 4:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "і ";
                                    break;

                                default:
                                    onesToOrdinal(tens % 10);
                                    result += " " + Ordinal.getClassName(classOfNumber) + " ";
                                    break;
                                }
                                break;

                            case false:
                                onesToOrdinal(tens);
                                result += Ordinal.getClassName(classOfNumber) + " ";
                                break;
                            }
                            break;

                        default:
                            switch (tens > 19 || tens < 4)
                            {
                            case true:                     // один мільйон-мільярд... і тд. два мільйони-мільярди...
                                switch (tens % 10)
                                {
                                case 1:
                                    result += Ordinal.getOnes(tens % 10) + "ин " + Ordinal.getClassName(classOfNumber) + " ";
                                    break;

                                case 2:
                                    result += Ordinal.getOnes(tens % 10) + "а " + Ordinal.getClassName(classOfNumber) + "и ";
                                    break;

                                case 3:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "и ";
                                    break;

                                case 4:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "и ";
                                    break;

                                default:
                                    onesToOrdinal(tens % 10);
                                    result += Ordinal.getClassName(classOfNumber) + "ів ";
                                    break;
                                }
                                break;

                            case false:
                                onesToOrdinal(tens);
                                result += Ordinal.getClassName(classOfNumber) + "iв ";
                                break;
                            }
                            break;
                        }
                        break;
                    }
                    break;
                }
                break;
            }
            return(result);
        }
Esempio n. 3
0
        protected override string convertHundreds(int hundreds, int tens, int classOfNumber)
        {
            result = "";
            switch (!Number.isNull(classOfNumber))//hundreds
            {
            case true:
                switch (hundreds != 0)
                {
                case true:
                    result += checkOnes(hundreds) + Ordinal.getClassName(0);
                    switch (classOfNumber == 0 && tens == 0)
                    {
                    case true:
                        result += "ste";
                        break;
                    }
                    result += " ";
                    break;
                }
                switch (tens > 19)     //tens
                {
                case true:
                    switch (tens % 10 != 0)
                    {
                    case true:
                        result += Ordinal.getOnes(tens % 10) + "und";
                        break;
                    }
                    result += Ordinal.getTens(tens / 10);
                    switch (tens % 10 == 0 || classOfNumber == 0)
                    {
                    case true:
                        result += "ste ";
                        break;
                    }
                    break;

                case false:
                    switch (classOfNumber == 0)
                    {
                    case true:
                        switch (tens)
                        {
                        case 1:
                            result += Ordinal.getLastOnes(tens);
                            break;

                        case 3:
                            result += Ordinal.getLastOnes(tens);
                            break;

                        default:
                            result += Ordinal.getOnes(tens) + "te";
                            break;
                        }
                        break;

                    case false:
                        result += Ordinal.getOnes(tens);
                        break;
                    }
                    break;
                }
                switch (classOfNumber > 0)    // classes
                {
                case true:
                    result += Ordinal.getClassName(classOfNumber);
                    switch (Number.getLastClass() == classOfNumber)
                    {
                    case true:
                        result += "ste ";
                        break;

                    case false:
                        switch (classOfNumber)
                        {
                        case 3:
                            result += "en";                 // milliard - en
                            break;
                        }
                        result += " ";
                        break;
                    }
                    break;
                }
                break;
            }
            return(result);
        }