как оптимизировать лучше

[MassonNN]

Всё, вопросы?

stock numlen(number){    if(number < 0)    {        if(number == cellmin)            number = (-(cellmin+1))+1;        else            number = -number;    }    if (number < 100_000)    {        if (number < 100)            return 1 + _:(number >= 10);        if (number < 10_000)            return 3 + _:(number >= 1_000);        return 5;    }    if (number < 10_000_000)        return 6 + _:(number >= 1_000_000);    if (number < 1_000_000_000)        return 8 + _:(number >= 100_000_000);    return 10;}

Он имеет ввиду пропиши этот сток (то есть попробуй заюзать) в main и попробуй скомпилировать.

[SteveStage]

Он имеет ввиду пропиши этот сток (то есть попробуй заюзать) в main и попробуй скомпилировать.

Так ты сам попробуй скомпилировать эту версию из цитированного тобой поста, он идеально компилируется и работает

Вопрос в том, зачем там вот это

Для того, чтобы использовать cellmin, замена модуля.

[Daniel_Cortez]

Лучше, мне кажется, уже нельзя.

Можно :)

Значение cellmin некорректно обрабатывается только определёнными функциями. Для условий все твои свистопляски не требуются, ибо всё будет работать корректно.

Эм... нет, не будет?
-2147483648 (cellmin) не имеет положительного представления в Pawn (т.е. -cellmin == cellmin), и поэтому первая же проверка (number < 100_000) сработает неправильно и функция выдаст 1.
Вот тебе и целочисленная арифметика... С другой стороны, в вещественных числах есть "+0" и "-0", которые с технической точки зрения имеют разное представление, но при этом считаются равными друг другу.

[DeimoS]

Для того, чтобы использовать cellmin, замена модуля.

if(number == cellmin)    number = cellmax;

Эм... нет, не будет?
-2147483648 (cellmin) не имеет положительного представления в Pawn (т.е. -cellmin == cellmin), и поэтому первая же проверка (number < 100_000) сработает неправильно и функция выдаст 1.

Я немного не так выразил мысль :) Подразумевал то, что если сравнивать именно cellmin, а не пытаться переводить отрицательные значения в положительные, то всё будет работать нормально.
Хотел написать и про то, что всю арифметику, которую Steve_Stage написал для перевода "cellmin", можно заменить на "cellmax", и про то, что гораздо лучше расписать условия для отрицательных значений отдельно, но отвлёкся при написании сообщения и мысли, в итоге, смешались в кучу =\

[SteveStage]

Можно :)

Ну в таком случае вариант с __emit - самый быстрый из предоставленных в этом посте.

[MassonNN]

Если не прибегать к ассемблеру, то нашёл ещё вот такой способ на просторах форума по c++, который просто более быстрее подводит сравнение:

if (n < 100000) {
            if (n < 100) {
                if (n < 10) {
                    return 1;
                } else {
                    return 2;
                }
            } else {
                if (n < 1000) {
                    return 3;
                } else {
                    if (n < 10000) {
                        return 4;
                    } else {
                        return 5;
                    }
                }
            }
        } else {
            if (n < 10000000) {
                if (n < 1000000) {
                    return 6;
                } else {
                    return 7;
                }
            } else {
                if (n < 100000000) {
                    return 8;
                } else {
                    if (n < 1000000000) {
                        return 9;
                    } else {
                        return 10;
                    }
                }
            }

[Daniel_Cortez]

Хотел написать и про то, что всю арифметику, которую Steve_Stage написал для перевода "cellmin", можно заменить на "cellmax"

Т.е. вот так?

if (number < 0){    if (number == cellmin)        number = cellmax;    else        number = -number;}

Если да, то можно сделать ещё немного проще:

if (number < 0)    number = -(number + _:(number == cellmin));

Такой трюк добавляет одну арифметическую операцию (сложение), но зато убирает лишнее ветвление и сопутствующее ему дублирование кода присваивания к переменной number. Собственно, примерно то же самое сделано и в моём варианте с __emit.

[DeimoS]

Если не прибегать к ассемблеру, то нашёл ещё вот такой способ на просторах форума по c++, который просто более быстрее подводит сравнение:

if (n < 100000) {
            if (n < 100) {
                if (n < 10) {
                    return 1;
                } else {
                    return 2;
                }
            } else {
                if (n < 1000) {
                    return 3;
                } else {
                    if (n < 10000) {
                        return 4;
                    } else {
                        return 5;
                    }
                }
            }
        } else {
            if (n < 10000000) {
                if (n < 1000000) {
                    return 6;
                } else {
                    return 7;
                }
            } else {
                if (n < 100000000) {
                    return 8;
                } else {
                    if (n < 1000000000) {
                        return 9;
                    } else {
                        return 10;
                    }
                }
            }

Так это тот же самый вариант. Просто ветвление условий чуть другое.

[vvw]

Если не прибегать к ассемблеру, то нашёл ещё вот такой способ на просторах форума по c++, который просто более быстрее подводит сравнение:

if (n < 100000) {
            if (n < 100) {
                if (n < 10) {
                    return 1;
                } else {
                    return 2;
                }
            } else {
                if (n < 1000) {
                    return 3;
                } else {
                    if (n < 10000) {
                        return 4;
                    } else {
                        return 5;
                    }
                }
            }
        } else {
            if (n < 10000000) {
                if (n < 1000000) {
                    return 6;
                } else {
                    return 7;
                }
            } else {
                if (n < 100000000) {
                    return 8;
                } else {
                    if (n < 1000000000) {
                        return 9;
                    } else {
                        return 10;
                    }
                }
            }

В компиляторе Pawn очень плохой оптимизатор, поэтому для реализации быстрых тривиальных функций все еще стоит использовать ассемблерные вставки. К слову, оптимизатор в этом языке может сделать удаление неиспользуемой функции, поиск блока инструкций по шаблону и замену этих инструкций на более короткие. Но стоит учесть, что интерпретатор на сервере не знает и большинства коротких инструкций.