Вопрос по программированию локальных переменных (HP 48GII, HP 50G)

Для объявления локальных переменных в программе без их предварительной загрузки в стек существует оператор LOCAL (<- означает один символ "стрелка влево" и указывает на локальность переменных) вот пример:
<< LOCAL ({'<-A=2','<-B=3'}) A B ^ >>
<< {'<-A=2','<-B=3'} LOCAL A B ^ >>
Но я попробовал много вариантов и мне выдаётся в ответ либо синтаксическая ошибка при попытке сохранить программу, либо в стек вводится строка символов, но численного решения нет.

Я знаю, что можно задать локальные переменные через стек при вызове программы например так:
<< -> A B << A B ^ >> EVAL>>

Но если в программе требуется десяток и более локальных переменных, то не задавать же им всем фиктивные значения в стеке перед вызовом программы, тем более, что при вызове передаются 2..3 параметра а остальные вычисляются в результате обработки данных.

Подскажите кто знает как можно объявить локальные переменные на RPL не замусоривая стек перед вызовом программы?

Я пока сделал, для начала, на глобальных переменных, которым объявляю PURGE в конце программы, но при этом возникает проблема согласования глобальных имён в главной программе и подпрограммах, что не очень-то красиво.

Taxonomy upgrade extras: 

Вопрос по программированию (HP 48GII, HP 50G). В первой строке примера очевидная ошибка:
LOCAL записан в алгебраической форме, а операция возведения в степень в RPN форме.
И в первой и во второй строке созданы локальные переменные <-A и <-B, но вычисления осуществляются с глобальными переменными A и B.
В RPN форме нужно записывать так:
<< {'<-A=2' '<-B=3'} LOCAL DROP <-A <-B ^ >> EVAL
Проверил на своем HP-50G, все работает :-)

Это что-же получается? Стрелку влево надо тащить через всю программу, как признак локальности переменной?
Спасибо попробую.

Да! Все получилось. Ещё раз спасибо!

Мои программируемые калькуляторы:
Б3-21, Б3-34, МК-61, МК-52, МК-85
CASIO: cfx-9850GB+, fx-9750G+, fx-9750GII, fx-9860G, Algebra fx-2.0, fx-5800P, fx-7400G+
HP: 50G, 48G, 35s
TI: Nspire-CAS, Voyage-200, 89Titanium
SHARP EL-9600G

Локальные переменные в HP-50G. Локальные переменные можно задавать и без использования команды LOCAL:
<< 2 '<-A' STO 3 '<-B' STO <-A <-B ^ >> EVAL
В этом случае не требуется команда DROP, т.е. после активации вычислений в стеке будет только результат возведения в степень.
Локальные переменные, также как и глобальные, занимают некоторый объем памяти калькулятора, но в отличие от последних не отображаются в меню переменных VAR.
Захламленность меню переменных служит поводом почистить память калькулятора, а в случае использования локальных переменных такой наглядности нет (после выполнения программы сами они, к сожалению, не удаляются).
Для удаления всех объявленных локальных переменных используется команда UNBIND.
Для указанного выше примера применение этой команды даёт следующий результат (если нет других локальных переменных):

UNBIND
{ '<-A=2' '<-B=3' }

Т.е. выводятся все локальные переменные с их значениями.

Забыл добавить локальным переменным в самой программе
в виде

<< 2 '<-A' STO 3 '<-B' STO >>,

все используемые локальные переменные должны быть
объявлены с помощью команды LOCAL, иначе появится
сообщение об ошибке.
Например, если ранее переменные '<-A', '<-B' и '<-C' были объявлены локальными, то присвоение новых значений можно задать списком:

{7, 8, 9}
{'<-A', '<-B','<-C'}
STO

Если же значений много, можно попробовать следующую
процедуру (объявляет 26 локальных переменных от A до Z):

<<
CLEAR
65
90
FOR I
" '<-"
I
CHR
" ' "
+
+
OBJ->
NEXT
DEPTH
->LIST
LOCAL
>> EVAL

Результат выполнения программы:
{<-A, <-B, .........., <-Z}

Понятно, что можно таким образом конструировать
любые необходимые имена переменных.

Сохранение в объявленных локальных переменных
необходимо выполнять ТОЛЬКО с помощью команды STO.
В противном случае наплодите клонов одной переменной.

Например, создадим локальную переменную A:

{ ‘<-A=1’ }
LOCAL

После применения команды UNBIND (удаление
объявленных локальных переменных):

UNBIND
{ ‘<-A=1’ }

А теперь попробуйте создать локальную переменную A
с начальным значением 1,
еще одну локальную переменную A с начальным значением
2 и, наконец, A со значением 3.
Возведение локальной переменной A в квадрат дает 9.
Выполняем удаление локальных переменных

UNBIND
{ ‘<-A=2’ }

Теперь возведение локальной переменной A в квадрат
дает 4 и т.д.

Т.е. переменная, которую мы объявляли как локальную,
одна, но в памяти имеются еще 2 ее клона
(имелись до удаления).

Еще пример программы:
Сохранение в первых десяти локальных переменных
первых десяти квадратов натуральных чисел.

<<
'X^2'
'X'
1
10
1
SEQ
65
74
FOR I
" '<-"
I
CHR
" ' "
+
+
OBJ->
NEXT
10
->LIST
STO
>>

При значительном количестве новых значений
переменных такой способ переприсвоения предпочтительнее раздельного (не списочного).

Кстати, в объявленные ранее переменные можно сохранять
списки, массивы, строки, программы, т.к. при
объявлении локальных переменных тип данных
не учитывается. Вероятно, работа с локальным массивом
в некоторых программах будет эффективной.

Если в процессе работы программы должно быть
организовано обращение к некоторым локальным
переменным из многих, то одним из решений может
быть создание списка имен локальных переменных,
вызывать любое из которых можно командой GET ...

:-)

Областью действия локальных переменных станет любая программа или подпрограмма, если
забыть при выходе из области, в которой переменная была объявлена,
удалить ее командой UNBIND.

Клоны и должны быть, если ипользуются одинаковые имена. Из всех клонов
переменной с одним именем активен тот,который был объявлен самым последним.
UNBIND удаляет текущий клон и возвращает предыдущий. Следующее применение
этой команды вернет локальную переменную определенную еще раньше и т.д.
Возврат всегда идет к предыдущей локальной переменной.

Если в работе программы не используется обработка ошибок и выход из цикла
до его естественного завершения, то все должно работать нормально, без неожиданных
реакций программы или результатов. Главное, не забывать в каждой области действия
локальной переменной (подпрограмме, цикле, функции, ... ) перед выходом из нее
применять UNBIND.

Пример:

<< {'<-A=1'} LOCAL
<< {'<-A=8'} LOCAL
'<-A' INCR >> EVAL
'<-A' INCR
<-A ->STR MSGBOX >> EVAL

Из примера видно, что о сохранении областей действия локальных
переменных должен заботится сам пользователь. Жаль, что это не делает
операционная система калькулятора, т.к. при использовании обработки ошибок
или "аварийного" завершения цикла в соответствующих частях этих блоков
придется учитывать все варианты возвратов к значениям локальных переменных определенных в предшествующих областях.

Если есть желание избежать головной боли с последующей длительной отладкой программы, то лучше не клонировать переменные (пусть будут локальными, но с разными именами).

Однако... Спасибо за столь подробное изложение темы. Теперь стало ясно, почему не сходился баланс между написанными программами и остатком памяти. В локальные переменные за время отладки утекло около 5 кб памяти и теперь, с Вашей помощью, их удалось вернуть :).

Я бы к Вашему изложению ещё добавил, что для очистки стека от списка освобожденных переменных (т.е. перед выходом из подпрограммы) следует дать последовательность команд:

{<-A <-B} UNBIND DROP DROP

а если освобождаем память от всех локальных переменных в конце программы, то последовательность короче:

UNBIND DROP

но даже в этом случае, если в памяти есть клоны одной переменной, уничтожается только последний из клонов.

Мои программируемые калькуляторы:
Б3-21, Б3-34, МК-61, МК-52, МК-85
CASIO: cfx-9850GB+, fx-9750G+, fx-9750GII, fx-9860G, Algebra fx-2.0, fx-5800P, fx-7400G+
HP: 50G, 48G, 35s
TI: Nspire-CAS, Voyage-200, 89Titanium
SHARP EL-9600G

Локалки .
> Но если в программе требуется десяток и более локальных
> переменных, то не задавать же им всем фиктивные значения
> в стеке перед вызовом программы,

А разве HP 50g не позволяет задавать значения переменных в самой программе, скажем:

« 2 3 → A B « A B ^ » »
EVAL

Если переменных тыщи, можно каким-нибудь NDUPN воспользоваться.

Этот вариант тоже возможен, но он не настолько универсален, как LOCAL ... UNBIND. Ведь не всем же локальным переменным необходимо присваивать значения в начале программы, некоторые вообще могут не использоваться, если программа пойдёт не по их ветви. Но у каждого из методов есть свои преимущества и недостатки.

Например в методе предложенном Вами область видимости локальных переменных ограничена фрагментом оформленным, как подпрограмма и после EVAL их уже не видно, и чтобы передать это значение далее, в последующие фрагменты программы, надо принимать дополнительные меры. Типа сохранить результат в стеке, или в другой, внешней по отношению к текущей локальной переменной или глобальной переменной до того момента, когда этот результат снова понадобиться. Когда таких результатов 1-2 и требуются они 1 раз, то можно и в стеке, а когда их десяток и требуются они неоднократно и не в том порядке, в котором вычислялись, то отладка такой программы в стеке потребует приличных усилий. А внешние, по отношению к текущему фрагменту, локальные переменные надо объявить в начале программы, либо через LOCAL либо забив в стек изначально десяток-другой незначащих нулей, чтобы зарезервировать память под локальные переменные (да ещё не ошибиться в количестве нулей и переменных). То есть это тот вариант который мне изначально не понравился.

Спасибо за участие!

Мои программируемые калькуляторы:
Б3-21, Б3-34, МК-61, МК-52, МК-85
CASIO: cfx-9850GB+, fx-9750G+, fx-9750GII, fx-9860G, Algebra fx-2.0, fx-5800P, fx-7400G+
HP: 50G, 48G, 35s
TI: Nspire-CAS, Voyage-200, 89Titanium
SHARP EL-9600G

Конечно. .
> область видимости локальных переменных ограничена фрагментом
> оформленным, как подпрограмма

Разумеется. В этом и заключаются идея структурного программирования и смысл локальных (т.е. существующих исключительно внутри блока) переменных.

Транслятор берёт на себя низкоуровневую работу по созданию и уничтожению переменных. Программист же следует принципам структурного программирования, сосредотачиваясь на решаемой задаче.

Что же до неинициализированных переменных, то это известное зло. Всё равно каждой создаваемой переменной приходится давать имя. Написать такое же количество ноликов нет проблем. Тем более, что формирование такого стека легко автоматизируется.

.
> и после EVAL их уже не видно, и чтобы передать это значение далее,
> в последующие фрагменты программы, надо принимать дополнительные меры.
> Типа сохранить результат в стеке, или в другой, внешней по отношению
> к текущей локальной переменной или глобальной переменной до того
> момента, когда этот результат снова понадобиться.

Именно так. Если значение используется в большей области видимости, то локальная переменная и определяется в этой, большей области видимости.

Если же значение требуется во всей программе, это глобальная переменная.

Все эти идеи были внесены в компьютерную науку во время перехода от Фортрана к Паскалю. Скажем, во времена Алгола. С тех пор в computer science появились и более мощные выразительные средства, например иерархия типов (Оберон) и протоколы (Zonnon).

:-)Вероятно, я выразился недостаточно точно.
Приведенная в качестве примера программа
показывает как делать нельзя:

<< {'<-A=1'} LOCAL
<< {'<-A=8'} LOCAL
'<-A' INCR >> EVAL
'<-A' INCR
<-A ->STR MSGBOX >> EVAL

Чтобы совершенно отчетливо представить, что
происходит с локальной переменной можно использовать
понятие "стек локальных переменных".

Если переменная A определена в различных частях
программы, например, пять раз (именно в таком порядке!)
*********************
{'<-A=1'} LOCAL
*********************
{'<-A=2'} LOCAL
*********************
{'<-A=3'} LOCAL
*********************
{'<-A=4'} LOCAL
*********************
{'<-A=5'} LOCAL
*********************
то стек локальных переменных будет "выглядеть" так:

5: <-A=1
4: <-A=2
3: <-A=3
2: <-A=4
1: <-A=5

Команда UNBIND удаляет локальную переменную с
вершины стека локальных переменных и выводит в
обычный стек ее имя и значение. На вершину стека
локальных переменных попадает <-A=4.

В приведенной выше программе в стек локальных
переменных сначала попадает <-A=1, затем выполняется
подпрограмма, в которой в стек локальных переменных
попадает <-A=8. Это значение увеличивается на единицу,
и управление переходит в основную программу (на вершине
стека локальных переменных осталась вторая <-A=9), где
значение <-A снова увеличивается на единицу. Однако, это
локальная переменная подпрограммы, а не такая переменная
основной программы, которая равна единице. Это можно
проверить, дважды выполнив UNBIND. Поэтому при использовании
команды LOCAL говорить об области видимости переменной
нельзя, т.к. областью видимости является вся программа и
даже ВСЕ ПРОГРАММЫ калькулятора. Т.е. если с вершины
стека локальных переменных не убрать значение,
использовавшееся в подпрограмме, оно будет доступно (видимо)
в любой другой программе.

Для локальных переменных программ подобных следующей
программе

<< -> N << 10 N * EVAL >> N 2 ^ EVAL >>

область видимости действительно ограничивается только
подпрограммами, т.е. здесь за этим следит сам калькулятор.
С переменными вида <-A и т.п. это не так, о чем и
свидетельствует приведенный ВЫШЕ пример.

Другой пример:

<< {'<-A=1'} LOCAL DROP
<< {'<-A=8'} LOCAL DROP
'<-A' INCR B + UNBIND DROP>> EVAL
'<-A' INCR
<-A ->STR MSGBOX >> EVAL

В этом случае областью действия видимости второй
локальной переменной является только подпрограмма,
о чем говорят результаты работы программы в стеке.
Поэтому я и предпочитаю говорить не об области видимости
локальных переменных вида <-A , а об области их действия.

Что касается произвольного доступа к локальным переменным
в стеке локальных переменных, то как его организовать неизвестно.
Поэтому если возврат к предыдущим значениям локальной
переменной с одним и тем же именем не последовательный,
то лучше использовать разные имена локальных переменных
и оператор присваивания STO для изменения их значений.

Для удаления ВСЕХ значений локальных переменных из памяти
калькулятора можно воспользоваться программой, которая
удаляет все элементы из стека локальных переменных:

<< 1 'T' STO
WHILE 'T==1'
REPEAT
IFERR UNBIND DROP
THEN 0 'T' STO
END
END
'T' PURGE >>

Использовать в качестве переменной-переключателя локальную переменную
нельзя, т.к. она в процессе работы этой программы будет удалена и при
проверке условия в WHILE-REPEAT-END возникнет ошибка.

:)

Поспешил с выводом, что произвольный доступ к стеку
локальных переменных (СЛП) организовать нельзя.

Это можно сделать через стек калькулятора. Если
можно получить доступ к любому элементу в стеке
калькулятора, то нужно просто перенести в него элементы
из стека локальных переменных, и манипулировать
ими с помощью команд работы со стеком.

Предположим что в стеке локальных переменных (СЛП)
содержится N наборов переменных (именно наборов,
т.к. если с помощью команды LOCAL был введен список
локальных переменных, то элементом на вершине стека
переменных будет весь этот список).
Пусть требуется в текущей подпрограмме вернуть
список значений локальных переменных содержащихся
на K-ом (считаем сверху вниз!) месте в СЛП.

Тогда:
1) Извлекаем с помощью команды UNBIND все элементы
СЛП в стек калькулятора;
2) Перемещаем K-ый список локальных переменных на
вершину стека с помощью K ROLL
(далее DEPTH ROLLD);
3) Сохраняем списки локальных переменных из стека
калькулятора в СЛП в том же порядке как раньше (сохраняется
и скопированный список переменных, а так как он
сохранялся последним, то он находится на вершине
СЛП и значения его переменных доступны в текущей подпрограмме);
4) После завершения подпрограммы возвращаем список
значений локальных переменных этой подпрограммы на
прежний уровень K;
ДЛЯ ЭТОГО: а) извлекаем с помощью команды UNBIND
все элементы СЛП в стек калькулятора;
б) Заменяем старый K-ый список новым списком
с помощью DEPTH ROLL K ROLLD, и сохраняем списки локальных
переменных из стека калькулятора в СЛП в том же порядке;
5) При переходе к следующей подпрограмме активируем
с помощью данной процедуры нужные значения локальных
переменных.

Вот программы, которые позволяют это делать:

LocRCL: ВЫЗОВ НУЖНЫХ ЛОКАЛЬНЫХ ПЕРЕМЕННЫХ
(лучше использовать глобальную переменную K или локальную
<-K, но определенную самой первой)

<< 1 'T' STO
WHILE 'T==1'
REPEAT
IFERR UNBIND
THEN 0 'T' STO
END
END
'T' PURGE
K ROLL
DEPTH
ROLLD
DO
LOCAL
DROP
UNTIL
DEPTH 0 =/=
END
>>

ВАЖНО!
Перед запуском этих подпрограмм
стек калькулятора должен быть пуст.

После работы этой программы (подпрограммы) на
вершине СЛП будет нужный набор локальных переменных,
а стек калькулятора будет пуст.

LocSTO: СОХРАНЕНИЕ ТЕКУЩЕГО СПИСКА НА ПРЕЖНЕМ K-ом УРОВНЕ

<< 1 'T' STO
WHILE 'T==1'
REPEAT
IFERR UNBIND
THEN 0 'T' STO
END
END
'T' PURGE
DEPTH
ROLL
K ROLLD
DO
LOCAL
DROP
UNTIL
DEPTH 0 =/=
END
>>

После работы этой подпрограммы будет обновлен
список значений локальных переменных сброшенных
в СЛП K-ми по счету.

Пример:

Содержимое СЛП (N=4):
4: <-A=7 <-B=8 <-C=9 <-D=10
3: <-A=4 <-B=5 <-C=6
2: <-A=2 <-B=3
1: <-A=1

Так как на вершине СЛП переменная <-A=1, то именно
значение 1 используется в выражениях содержащих <-A
(кстати, значение переменной <-D=10 тоже доступно).
Предположим, что нужно "загрузить" набор переменных
{<-A=4 <-B=5 <-C=6}, т.е. второй в СЛП, если считать
сверху вниз (K=2).

ПРОГРАММА №1:

<< Основная программа
**************
**************
**************
<< Какая-то подпрограмма
2 'K' STO
LocRCL
**************
**************
Тело подпрограммы,
использующее локальные переменные <-A, <-B, <-C
**************
**************
LocSTO 'K' PURGE>>
**************
**************
**************
**************
>>

ПРОГРАММА №2:

<<
2 'K' STO
LocRCL
'(<-A+<-B)*<-С' EVAL
'ANSW1' STO
LocSTO
3 'K' STO
LocRCL
'(<-A+<-B)^2' EVAL
'ANSW2' STO
LocSTO
1 'K' STO
LocRCL
'C*D-A*B' EVAL
'ANSW3' STO
LocSTO
ANSW1
ANSW2
ANSW3
>>

Правда теперь при программировании нужно будет
помнить или записывать на каком уровне в СЛП
какие находятся локальные переменные и
для какой подпрограммы.
Подпрограммы LocRCL и LocSTO
Можно объединить в одну.
Параметр K в этих подпрограммах
можно задавать как локальную переменную первого вида, т.е.

<<
->K <<подпрограмма>>
>>

Если в работе программы появится
новая ветка и соответствующие
новые локальные переменные,
то и в этом случае LocSTO и
LocRCL будут работать корректно.

:)

ОЧЕПЯТКА. В конце подпрограмм
должно стоять ==,
а не =/=.
Ну все, буду спать,
а то всю ночь соображал
как это все можно сделать.

Спасибо спасибо! Это даже более подробно, чем я мог надеяться.

Можно поинтересоваться у Вас, Vlad_AB, откуда Вы столь подробно знаете User RPL?

Мои программируемые калькуляторы:
Б3-21, Б3-34, МК-61, МК-52, МК-85
CASIO: cfx-9850GB+, fx-9750G+, fx-9750GII, fx-9860G, Algebra fx-2.0, fx-5800P, fx-7400G+
HP: 50G, 48G, 35s
TI: Nspire-CAS, Voyage-200, 89Titanium
SHARP EL-9600G

А я и не знаю :-). HP-50G у меня пару месяцев.
До него работал (и работаю) с TI-89.
С RPN раньше никогда не работал.
Как пришла посылка с калькулятором, посмотрел и понял,
что совсем ничего не понимаю. Закинул в стол подальше.

По работе сталкиваюсь с различными объемными вычислениями. Решил
понемногу переписывать в HP программы написанные для TI.
Довольно долго читал UG и AUR. Пока освоился недостаточно хорошо.
С программированием графики, например, нет времени пока разбираться.
Хотя знаю, что это потребуется для программирования
каких-нибудь игрушек :)

Вопросом по локальным переменным раньше не занимался.
Работал с глобальными переменными и удалял их в конце программы,
но после отладки программ чистить меню переменных замучился. Заглянул сюда.
Оказалось, что не я один так мучаюсь. Вот и появился дополнительный
повод разобраться, самому потом в любом случае пригодится.

В целом HP-50G очень доволен (с RPN работать как-то шустрее, чем с алгебраическим
режимом), но есть ряд негативных моментов (перечислю лишь основные):
1) В символьном виде системы уравнений решать не может;
2) Некоторые пределы считает с ошибками;
3) Не поддерживает решение неравенств с параметрами;
4) Несобственные интегралы второго рода считает с ошибками;
5) Нет команд программирования для выхода из цикла до его естественного завершения;
6) Нет оператора произведения (в TI есть);
7) Очень долго численно считает интегралы;
8) Нет Label ... Goto (это, правда, небольшая потеря, но пункт 5 можно было бы реализовать);
9) Не очень удобно реализовано меню редактирования (кнопки).

Плюсов гораздо больше (перечислю основные):
1) Поддержка карт памяти; у меня на компьютере Vista и поэтому связь с компьютером могу реализовать только через карточку (так обновил встроенное ПО);
2) Хорошая клавиатура ? (время покажет);
3) Хороший экран, глаза напрягать не нужно;
4) Есть пищалка;
5) Очень удобно работать с EQW (можно преобразовывать части выражений - фантастика);
6) Можно менять размер шрифта;
7) Цифры и буквы на отдельных клавишах, не нужно переключать;
8) Матрицы прокручиваются быстрее;
9) Очень эффективно работать со стеком (разобрал-добавил-убрал-собрал), прямо конструктор какой-то;
10) Будильник позволяет запускать не только звуковой сигнал, но и программы;
11) Дисплей закрыт стеклышком :)
12) т.д. и т.п.

Где-то читал что недостатком HP-50G считается неточность встроенных часов.
У меня отстают за 24 часа секунды на 2 (сейчас проверяю, что будет через
100 суток). Узнаю разность суточного хода точнее и пропишу в будильник
программу с командой CLKADJ (будет по ночам запускаться и корректировать
ход часов). Здесь также пригодится команда OFF.

Короче, мне HP-50G еще осваивать и осваивать.

Если не секрет, то для чего (что делает программа) понадобилось такое
количество локальных переменных и возможность сохранения их значений
после выхода из подпрограмм?

Не секрет :). Дело в том, что я преподаю в ВУЗе (и не только) и для проверки расчетных практических заданий самым удобным оказался программируемый калькулятор. У меня ещё со студенческих времён жив МК-52, но там памяти оказалось катастрофически мало. Попробовал поискать другие ПМК и максисум, что нашёл тогда в Украине - это Sitizen SRP-325G. Купил его по почте (из Севастополя в Одессу). Это было лучше, но не на много поэтому спустя короткое время избавился от него. Поэтому взял и года два назад зарегистрировался ни и-бей. Купил CASIO fx-9750G+ и основные типовые задачи, которые встречаются в процессе обучения запрограммировал сначала в нём, хотя туда всё влезло "с большим скрипом", а затем стало любопытно, а что собой представляют современные ПМК, поэтому приобрёл TI-89, ti-92, CASIO Algebra fx-2, CASIO fx-9860G, HP-50G, HP-48GII... В общем увлёкся. Некоторые калькуляторы даже перепродал желающим с небольшой выгодой для себя. Теперь набор программного обеспечения написан мной под все эти калькуляторы кроме HP. Они оказались последними в этом ряду, к которым у меня дошли руки и я сейчас этим не спеша занимаюсь. Да, ещё был у меня CASIO fx-7400G+, но его возможностей не хватило для моих потребностей и сейчас он тоже в других руках. Думал ещё об МК-161, но спросил у СЕМИКО и мне ответили что с доставкой около 6000 руб. За эти деньги я могу приобрести TI Nspire CAS. Поэтому МК-161 я пока не покупал. Да и 10 кб памяти программ в МК-161 мне не хватит на всё.

Ну а типовые задачи - это вычисления в конечных полях Галуа, алгебраических группах и кольцах, типовые двухключевые алгоритмы шифрования распределения ключей и цифровой подписи в том числе и над эллиптическими кривыми, а так же методы криптоанализа несимметричных шифров, то есть факторизация и дискретное логарифмирование и т.д. В TI и ещё бльше в HP некоторые элементарные операции этой алгебры уже доступны в виде команд.

Кстати, а что мешает подключиться НР-50G к ПК по USB вместо SD? Я со своего НР-48GII подключаюсь к ПК через СOM и HP-50 тоже подключал по USB, но тогда только картинку с экрана срисовывал. Там для активации связи с ПК надо дать на калькуляторе команду XSERV, а затем активировать подключение из Calculator connectivity kit. После этого можно манипулировать с ПК данными на ПМК.

Мои программируемые калькуляторы:
Б3-21, Б3-34, МК-61, МК-52, МК-85
CASIO: cfx-9850GB+, fx-9750G+, fx-9750GII, fx-9860G, Algebra fx-2.0, fx-5800P, fx-7400G+
HP: 50G, 48G, 35s
TI: Nspire-CAS, Voyage-200, 89Titanium
SHARP EL-9600G

Пробовал через USB, но на Висте программа виснет (проблемы
с совместимостью). На сайте HP есть подтверждение
этому, а также рекомендация использовать карту памяти.

Аналогично, увлекаюсь коллекционированием :] и преподаванием.
Калькуляторы использую не только для проверки типовых расчетов студентов,
но и для их генерации (обычно менее 30 вариантов не бывает).
Библиотеку генераторов и решателей основных типов задач начинал
составлять на Casio fx-9750G PLUS. Еще раньше работал с
SRP-320G. Titanium освоил достаточно быстро (включая программирование
графики), интуитивно понятен как Casio. С HP-50G быстро разобраться
не получилось. Для работы с ним нужен другой способ мышления. Теперь
гораздо чаще работаю с HP, "подсел" на RPN.

Думал купить Casio fx-9860G или Algebra fx-2.0, но почитав руководства пользователя, передумал. Возможности практически такие же как у
Casio fx-9750G PLUS, с учетом решаемых задач выигрыш по встроенным командам и функциям, памяти и быстродействию незначительный. У Casio Algebra CAS слабенькая,
ограничения на имена переменных (да еще читал флеш быстро выходит из строя). Работал с эмулятором ClassPad 300, интересная модель, но не люблю сенсорные экраны.
Но на принятие окончательного решения повлияло отсутствие поддержки необходимых
функций. TI-Nspire CAS изучал по руководству пользователя (не нашел AUR).
Но сделанных наблюдений достаточно, чтобы решить его не покупать.
Конечно, памяти по сравнению с TI-89 и HP-50G очень много и частота процессора
больше. Однако, в реализации программирования он не дотягивает до уровня TI-89
(Titanium).

МК-161 как вариант тоже рассматривался. Считает быстрее, но памяти маловато.
Нет некоторых нужных функций. В HP, например, возможности работы со строками и
выражениями таковы, что можно написать программу, которая будет писать программы.
Как вариант, программа изменяющая свой код, добавляющая (изменяющая)свои подпрограммы, "самообучающаяся" (хотя памяти для ведения статистики и хранения баз данных у калькулятора маловато, а работа с картой памяти быстро расходует заряд батарей). Еще один вариант, программа переписывающая старые алгоритмы в подпрограммах на новые (возможно из-за наличия в новой версии ПО калькулятора
новых команд). Ну, это пока только фантазии :)

В принципе Алгебра считает раза в полтора быстрее, чем 9750, а вот 9860 считает в 8 раз быстрее и для него появился подгружаемый во флэш русификатор, так что там все менюшки уже могут быть с русскими комментариями, что я со своим 9860 уже сделал. Есть также небольшие проблемы с совместимостью. Возможно в 9860GII русский интерфейс уже зашит в системное ПО изначально, как английский, французский, немецкий...

А кстати, Вы в каком городе проживаете?

Мои программируемые калькуляторы:
Б3-21, Б3-34, МК-61, МК-52, МК-85
CASIO: cfx-9850GB+, fx-9750G+, fx-9750GII, fx-9860G, Algebra fx-2.0, fx-5800P, fx-7400G+
HP: 50G, 48G, 35s
TI: Nspire-CAS, Voyage-200, 89Titanium
SHARP EL-9600G

Наличие кириллицы не является
для меня значимым при
выборе калькулятора.
Конечно, это было бы
удобно, например, при
генерировании условий
типовых заданий.
Покупать устройства менее
функциональные чем TI
или HP как-то не тянет.

Можно выбирать калькуляторы по
различным параметрам:
- возможность расширения памяти;
- частота процессора;
- объем оперативной памяти;
- разрешение экрана;
- поддержка разных типов данных;
- наличие развитого языка программирования;
- возможность подключения к другим устройствам;
- и т.д.
Не считаю, что нужно непременно приобретать все новые
модели современных ПМК (хотя это было бы интересно :) )
не освоив на должном уровни уже приобретенные модели.
Так получилось с Casio FX-9750G Plus, работая с которым
почувствовал потолок (быстродействие или объем памяти
были непричем, хотя в последней частенько ощущалась
нехватка) - не было возможностей реализовать некоторые
задумки. Поэтому пока хорошенько не освою TI-89T и
HP-50G вряд ли куплю новую модель. Под мои задачи
они подходят хорошо; для тех задумок, которые
запланировал, препятствий пока нет.
Может, если что-то потом и вызовет трудности с
запрограммированием, то только тогда и буду
решать что делать дальше (покупать новый
калькулятор или садиться за компьютер).

Сейчас, к сожалению, совсем нет времени
на программирование игрушек,
там частенько находились интересные
решения, которые можно было применить
в других программах.

Проблему с совместимостью ПО для подсоединения
калькулятора к ПК не считаю таковой, мелкая
неприятность, на которую можно не обращать
внимания.

Я живу в Омске :]

Конструктор. Комментарий был перемещен и теперь находится здесь.

Неудобно. Доброе Утро !

Конечно, правильно разместить "Конструктор", как отдельную тему.
И за это модератору спасибо.
Но, по-моему, с "Локальные переменные в HP-50G" это перебор, так как теперь изначально цельный разговор о локальных переменных размазан по двум темам. По-моему, это неудобно.

_________________
Dima Masalov
FIDO-NET - 2:461/640.9 AKA 2:461/43.9
E-MAIL - mds at ire dot kharkov dot ua

_________________
Dima Masalov
E-MAIL - mds at ire dot kharkov dot ua

Согласен это неудобно.
Может быть вернуть оторванное обратно?
:)

Вернул в общую ветку.
Однако, было бы интересно, например, оформить сравнение HP и TI отдельной записью.
Если напишете, я пристыкую комментарии отсюда.

Сравнение HP 50g и TI-89 Titanium. Комментарий был перемещен и теперь находится здесь.

_________________
Dima Masalov
E-MAIL - mds at ire dot kharkov dot ua