Архитектура компьютера→Троичный язык программирования

Основная сложность - троичная логика. В простой логике: 0 - ложь, 1 - истина. Здесь, наверно, -1 - ложь, 0 - неопределенно, 1 - истина
Кидайте свои идеи

Впредь предлагаю обсуждать такие вопросы:
1. Реализация троичной логики в условных операторах
2. Обозначения состояний трита
3. Логический тип данных
4. Количество трит в трайте
5. Кодовая таблица (тесно связан с вопросом 4)
6. Алгоритм переода из десятичной системы в уравновешенную троичную и обратно)

Мои предложения:
1. Насколько я разбираюсь в теории программирования, операции if - else, циклы while и for, переключатель switch и прочие ветвления и циклы можно перевести к оператору условного перехода goto: if условие goto адрес_перехода. Если еще проще, то в двоичной ЭВМ это сводится к двум развовидностям оператора:
if a==1 goto адрес
if a==0 goto адрес,
где a - логическая переменная (результат выполнения сравнения).
Пример:
bool k=(a>b);
if k==1 goto metka1;
if k==0 goto metka2;
В троичной логике:
if k==0 goto met1;
if k==+ goto met2;
if k==- goto met3;
(В Сетуни используется этот вариант: команды: 0+0, 0++, 0+-)

2. В принципе обозначать можно как угодно. Я знаю такие распространенные варианты:
1) -0+
2) NOP
3) NZP
4) -1 0 1
Голосование по этому поводу проводить рано, сначала надо рассмотреть аргументы. У меня такие:
1) -0+ вроде интуитивно понятно, но зачем придумывать (+) и (-) для обозначения сложения и вычитания, когда несколько веков используют просто + и - (к тому же () - это операторные скобки)
2) NOP и 3) NZP дополнительно надо объяснять, о чем идет речь
-
4) 1 0 1 основная сложность, что в таблице символов ASCII нет сомвола для -1 (насчет UNICODE не знаю), поэтому такая нотация сложна для обсуждения.
Это насчет состояний трита.

3. Другой вопрос - логический тип данных. Конечно, можно его не вводить (как не было его, например, в языке C), а пользоваться обозначениями состояний трита, но я предлагаю все-таки ввести: тип boolean (или bool, BOOL, кому как нравится). Диапазон значений:
1) false
2) null (undefined)
3) true
С другой стороны возникает вопрос о "таблице истинности" с трехмерной логикой. В теории реляционных баз данных используется такая таблица

A B not A A and B A or B a==B
1. false false true false false true
2. true false true false true false
3. true true false true true true
4. true null null null true null
5. false null null false null null
6. null null null null null null

4. В принципе, количество трит в трайте может быть любым (в байте не всегда было 8 бит, когда-то их было 7 или 6). По этому поводу в Википедии есть очень интересная заметка (http://ru.wikipedia.org/wiki/Трайт). Я предлагаю рассматривать следующие варианты, как наиболее логичные:

1) 1 трайт=1 три (и дальше не париться)
2) 1 трайт= 3 трит (первое число, являющееся степенью тройки)
3) 1 трайт= 6 трит (как в ЭВМ Сетунь)
4) 1 трайт= 9 трит (3^2, по аналогии 1 байт= 8 бит (2^3))
5) 1 трайт=27 трит(наиболее логичный вариант, так как 27=3^3, но слишком громоздко)

5. Идея utf-8 хороша, но ее придумали для обратной совместимости с ASCII, а у нас обратно совмещать не с чем, поэтому все-таки удобно, когда любой символ кодируется одинаковым количеством трайт (трит). Это упрощает многие алгоритмы (представить алгоритм поиска симола в строке с кодировкой utf-8). Я предлагаю рассмотреть такие варианты:
1) 1 трайт=6 трит (3^6=729 - явно мало, если использовать два трайта, то 3^12=531441, что достаточно (на настоящее время))
2) 1 трайт=9 трит (3^9=19683 - уже больше, но не годится для аналогии с 2^16=65536, а два трайта - 3^18=3*10^8 (скорость света!!!) хватит до скончания веков - IMHO)
3) 1 трайт=27 трит - тут хватит еще больше, чем до скончания веков

6. Я предлагаю такой алгоритм: десятичное число представляется ввиде линейной комбинации: 349=3*10^2+4*10^1+9*10^0. Далее преобразование проводится для каждого разряда в отдельности (этих вариантов не много и их можно хранить в памяти), а результаты складываются:
349=3*10^2+4*10^1+9*10^0=++-0+0(+)++++(+)+00=+++0-+ (как неудобно использовать (+) :-)

1. Я имел в виду язык ассемблера (или машинный код), где инструкции записаны по порядку и нельзя создавать блоки {} (весь ко дна одном уровне):

149D:0100 MOV AH,02
149D:0102 MOV DL,41
149D:0104 MOV CX,001A
149D:0107 INT 21
149D:0109 INC DL
149D:010B LOOP 0107
149D:010D INT 20
149D:010F.

Единственный способ организовать условный переход в такой ситуации - использовать оператор goto (или иму подобные). В приведенном примере замыкается цикл оператором loop.
В нормальных языках программирования, где в принципе возможно неограниченное число вложенных структур, конечно, удобно использовать for, while, if, switch и прочие прелести языков высокого уровня. Я имел в виду, что любая конструкция при компиляции в машинный код сводится к некоему подобию оператора goto (я почти ничего не понимаю в языке ассемблера, поэтому знатоки могут меня поправить).
На мой взгляд при реализации двоичной логики в программировании превалирует идея: условие выполняется или нет (третьего не дано). У нас есть возможность добавить другие возможности. Например:
1) если у объектов есть понятие "больше", "меньше", "равно" (как например у чисел), то можно ввести оператор compare(x,y), который возвращает одно из этих трех
2) логический оператор может возвращать false, Null, true

2. Второй вопрос, насколько я понимаю, вы предлагаете похоронить. В принципе, если нет необходимости в поразрядной записи, то какая разница, как ее обозначать. Единственный пример, который мне приходит в голову, это расчет сетевых адресов в стеке протоколов TCP/IP (протокол IPv4: 142.123.56.2), но это уже не проблема, так как в IPv6 будут переходить к шестнадцатеричной записи.

3. Если обозначать состояния трита можно как угодно (- 0 +, NOP, NZP, -1 0 1), то для логического типа данных нужно выбрать обозначения. То, что (-1) - false, а 1 - true, ИМХО, можно не дискутировать. Для нуля есть несколько вариантов:
1) null (можно спутать с нулевым указателем NULL в C++)
2) nil (в языке LISP обозначает ложь, поэтому не логично)
3) None (неопределенное значение например в Python)
4) undefined (слишком длинно писать)
5) nothing (ИМО, это в Visual Basic что-то типа проверки на пустоту)
6) empty (это мне совсем не нравится)

Я все-таки склоняюсь к варианту null, который давно используется в реляционных БД (и обозначает именно - неопределенное)

Таблицу истинности я списал из тетрадки по базам данных, поэтому ссылку дать не могу. Наберите в Google "таблица истинности null" и узнаете много интересного. Любопытно было почитать "http://articles.org.ru/docum/sql_oper.php" и "http://www.interface.ru/home.asp?artId=2407"

4. По определению:
Трит - минимальная единица информации
Трайт - минимальная адресуемая ячейка памяти

Исторически сложилось, что 1 байт=8 бит. ИМХО, это возникло в пору, когда в ходу было 8-разрядные процессоры. Когда потом появились 16-разрядные, то было написано уже много кода, ориентированного на то, что 1 байт=8 бит, и решили так и оставить. Поэтому и сейчас на 64-разрядных процессорах 1 байт=8 бит, хотя эффективность в этом случае слегка ниже, чем если бы было 1 байт=64 бит. Процессору выгоднее обрабатывать 64-разрядные слова, чем дробить их на 8-разрядные.
По этой же причине логический тип данных сделан размером в 1 байт, а не в 1 бит, хотя это и сэкономило бы много памяти, но разбирать 1 байт по битам невыгодно с точки зрения быстродействия. Вообще, сейчас для 90% пользователей на первый план выходит быстродействие, а не память, которая при этом теряется (благо современные технологии это позволяют). ИМХО
Я думаю, что размер трайта должен эффективно подстроиться под кодовую таблицу символов, которую мы, надеюсь, придумаем

5. Посмотрел ваши цифры и понял, что сколько трит (или бит) под кодовую таблицу не оставляй, все равно рано или поздно не хватит, поэтому идея utf-8 выглядит неплохо. С этой точки зрения 6-тритового трайта должно хватить для кодировки основных символов (отсюда логично название UTF-6). В оригинальном UTF-8 какая-то замудренная логика, по которой определяется, сколько байт отведено под символ, если он не из ASCII. Надо придумать что-то попроще. Так же необходимо указать максимальное количество трайт, приходящихся на один символ.
Другой вариант (для наглядности взял 1 трайт=6 трит): в первом трайте у нас 3^6=729 комбинаций. Допустим, чтобы закодировать основные символы (назовем их также - ASCII) у нас ушло 5 трит (3^5=243) и 1 остался (пусть он будет первый). Для ASCII он равен 0. Если первый трит не ноль (-1 или +1), то значит символ не из ASCII и в последующих 5 тритах вместо кода ASCII записывается натуральное число - сколькими трайтами закодирован данный символ. То есть в принципе можно использовать 3^5=243 трайт, что позволяет закодировать (3^6)^243=4*10^695 символов. Можно хоть смайлики кодировать. Нужно только правильно выбрать коды для символов: основные (ASCII) у нас кодируются 1 трайтом, часто употребляемые 2-4 трайтами, далее остальные. ИМХО, получилось что-то похожее на дерево Хаффмана (скорее не по структуре, а по идее).
Отсюда у меня возникает предложение (знатоки языков C/C++ меня поймут): надо отделить строковый тип данных и тип данных, предназначенный для побитового (у нас потритового) представления объекта (в C++ - это char). Для символа нужно создать тип char, а для потритового представления тип - tryte (я надеюсь, я правильно написал "трайт" по-английски, а "трит" пишется "trit" ИМО). Ни программист, ни пользователь не должны подозревать, сколькими трайтами закодирован данный литерал. Если пользователь еще переживет, то программисту нужно "образать" возможность что-нибудь оптимизировать для типа char. Все операции для типа char должны быть "вшиты" в язык (инкапсулированы от пользователя и программиста).
По этому вопросу можно открыть отдельную тему, если кому интересно.

6. Ваш вопрос - на каком порядке остановиться. Возьмем для примера язык C++. Для 32-разрядного процессора (4 байта) наибольшее целое число 2^32=4 294 967 296, то есть можно остановиться на 10-ом порядке десятичного числа, то есть имеем 100 вариантов (по 10 для каждого разряда), то есть понадобится 4*100=400 байт. Если учесть, что эту операцию нужно проводить довольно часто, 400 байт памяти не жалко. Для 64-разрядного числа нужно 800 байт. ИМО, для троичной системы исчисления цифры сильно не поменяются.
Одна проблема: как с помощью этого алгоритма преобразовать число братно в десятичную систему из уравновешенной троичной.

Thunguska the ternary computer emulator
http://www.acc.umu.se/~achtt315/tunguska/
По сообщению разработчика разрабатываются: троичный ассемблер, троичный компилятор с С, троичная операционная система. Желающим предлагается скачивать текущие версии.

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

1. Для начала советую обратить внимание на реляционный язык SQL, где применяется троичная логика.

2. Поддерживаю булевский тип BOOLEAN (FALSE, NULL, TRUE) = (-1, 0, 1), как вариант (FALSE, UNDEF, TRUE) (UNDEF мне нравится больше, так как выражает сущность - неизвестно). Кстати, можно на 7 сегментных индикаторах вместо -1 выводить F, а чтобы не путать её с шестнадцатиричной системой, развернуть на 180 градусов. Получится уникальный символ :).

3. Базовую конструкцию IF использовать следующим образом (стиль оберона):
IF <condition> {CORRECT <true>} {UNKNOWN <undef>} {WRONG <false>} END;
Таким образом возможны следующие варианты:
1. IF (a > 5) CORRECT proc1 END;
2. IF (a > 5) UNKNOWN proc1 END;
3. IF (a > 5) WRONG proc1 END;
4. IF (a > 5) CORRECT proc1 WRONG proc2 END;
5. IF (a > 5) CORRECT proc1 UNKNOWN proc2 END;
6. IF (a > 5) UNKNOWN proc1 WRONG proc2 END;
7. IF (a > 5) CORRECT proc1 UNKNOWN proc2 WRONG proc3 END;

4. Однозначно определить циклы (стиль оберона) WHILE <condition> DO <body> END; и DO <body> WHILE <condition> END как циклы исполняющиеся пока <condition> = TRUE;
и циклы (стиль оберона) REPEAT <body> UNTIL <condition> END; и UNTIL <condition> REPEAT <body> END; как циклы исполняющиеся пока <condition> # TRUE, т.е. = FALSE или UNDEF.

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

Нашёл табличку с функциями: инверсия, и, или, следование, эквивалентность

Сразу оговорюсь, что здесь приводится не полный вариант сиснтаксиса языка, а лишь часть, касающая основ реализации троичной логики
Итак, предлагаются следующие конструкции:

Логический тип данных:
ЛОГ[ИЧЕСКИЙ]

диапазон значений:
ИСТИНА
ЛОЖЬ
НЕОПР[ЕДЕЛЕННО]

Оператор присваивания
:=
перем=ИСТИНА

Оператор сравнения (проверка на равенство)
==
возвращает логическую переменную
ИСТИНА==ИСТИНА //истина
ЛОЖЬ==ИСТИНА //ложь
НЕОПР==НЕОПР //неопределенно

Оператор сравнения (проверка на неравенство)
!=
возвращает логическую переменную
ИСТИНА!=ИСТИНА //ложь
ЛОЖЬ!=ИСТИНА //истина
НЕОПР!=НЕОПР //неопределенно

Таким образом мы исключаем знак "=" вообще, дабы не делали ошибок (для одних "=" ассоциируется с присваиванием, для других - с сравнением)

Прочие операторы сравнения: <, >, <=, >=
Также предлагается оператор, возвращающий > или < или == в зависимости от ситуации (предлагаемое обозначение >=< или >==<)

3>==<4 //ЛОЖЬ, интерпретируется как меньше
4>==<4 //НЕОПР, интерпретируется как равно
5>==<4 //ИСТИНА, интерпретируется как больше
В связи с этим можно ввести еще 3 равносильных литерала:
ЛОЖЬ МЕНЬШЕ
НЕОПР РАВНО
ИСТИНА БОЛЬШЕ

Оператор проверки соответствия:
ЯВЛ[ЯЕТСЯ]
возвращаемое значение: логическая переменная
Предполагается ИСТИНА или ЛОЖЬ, но для пользовательских типов может быть установлено НЕОПРЕДЕЛЕННО

ИСТИНА ЯВЛ ИСТИНА //истина
НЕОПР ЯВЛ НЕОПР //истина


Оператор проверки отсутствия соответствия:
НЕ ЯВЛ[ЯЕТСЯ]

ИСТИНА НЕ ЯВЛ ЛОЖЬ //истина
НЕОПР НЕ ЯВЛ НЕОПР //ложь

Про операторы ЕСЛИ и ЦИКЛ пока речи не идет, так как мы не разобрались еще с логикой, а они работают на логике.

Жду высказываний против :-)

Над выбором слова для среднего значения надо ещё подумать, поскольку, например, для сравнения двух чисел будет весьма нелогично в случае равенства выдавать значение, называемое «неопределено» (или, тем более, «неизвестно»). С ним же возникает некоторая путаница в логике при использовании слова ИНАЧЕ. В конце концов, это слово обозначает строго определённое значение, а неизвестным может являться лишь результат решения определённой группы задач, на который указывает (при том весьма условно) это логическое значение.

В продолжение темы об условии. Тут тоже надо подумать над выбором слов.

Я предлагаю такую схему условия:
ЕСЛИ усл ТО
действ1 (* усл = ИСТИНА *)
[В ОБРАТНОМ СЛУЧАЕ]
действ2 (* усл = ЛОЖЬ *)
[В СЛУЧАЕ НЕОПРЕДЕЛЁННОСТИ]
действ3 (* усл = НЕОПР *)
КОН

Это же можно записать, используя слово ИНАЧЕ. Либо так:
ЕСЛИ усл ТО
действ1 (* усл = ИСТИНА *)
[В ОБРАТНОМ СЛУЧАЕ]
действ2 (* усл = ЛОЖЬ *)
ИНАЧЕ
действ3 (* усл = НЕОПР *)
КОН

Либо так:
ЕСЛИ усл ТО
действ1 (* усл = ИСТИНА *)
[В СЛУЧАЕ НЕОПРЕДЕЛЁННОСТИ]
действ3 (* усл = НЕОПР *)
ИНАЧЕ
действ2 (* усл = ЛОЖЬ *)
КОН

Условие можно записывать и в привычной для двоичной логики форме:
ЕСЛИ усл ТО
действ1 (* усл = ИСТИНА *)
ИНАЧЕ
действ2 (* усл = ИСТИНА ИЛИ усл = НЕОПР *)
КОН

Следует упомянуть и указание АЕСЛИ, которое заменяет конструкцию ИНАЧЕ ЕСЛИ. В троичном ЯП АЕСЛИ также может заменять ИНАЧЕ при наличии вложенного условия:
ЕСЛИ усл1 ТО
действ1 (* усл1 = ИСТИНА *)
[В СЛУЧАЕ НЕОПРЕДЕЛЁННОСТИ]
действ2 (* усл1 = НЕОПР *)
АЕСЛИ усл2 ТО
действ3 (* усл1 = ЛОЖЬ; усл2 = ИСТИНА *)
...
КОН

Предлагаю обсудить предложенный мною вариант. Если он является приемлимым, то надо выбрать подходящие слова вместо [В ОБРАТНОМ СЛУЧАЕ] и [В НЕОПРЕДЕЛЁННОМ СЛУЧАЕ].

Я уже предлагал компактный вариант для условных операторов. Если нам надо рассмотреть все 3 случая отдельно, то лучше воспользоваться оператором ВЫБОР:

ВЫБОР (усл):
{
ЛОЖЬ: операторы;
НЕОПР: операторы;
ИСТИНА: операторы;
}

Все четко и понятно. Все три возможных значения равноправны, можно менять их порядок или даже пропускать. Если же надо обработать одно условие и его альтернативу, то тогда применяетмя один из ЕСЛИ:

ЕСЛИ_ИСТИНА (усл) операторы;
ЕСЛИ_НЕОПР (усл) операторы;
ЕСЛИ_ЛОЖЬ (усл) операторы;

пример.

ЕСЛИ_ИСТИНА (перем1==перм2): Вывод("истина");
ИНАЧЕ Вывод ("ложь или неопределенно");

Что касается оператора СРАВН. Его луше сделать функцией стандартной библиотеки, возвращающей логическое значение:
к==л НЕОПР
к>л ИСТИНА
к,

Снова про среднее значение. Разобравшись с ним, можно будет оформить предварительную версию основной части троичного высокоуровневого языка. Ведь с арифметическими действиями, циклами и (будем считать) условиями разобрались.
Логических значений может быть весьма много. Кроме истины и лжи может быть «не истина, и не ложь», «и истина, и ложь», «значение неизвестно или нефиксировано», «значение не может быть определено» и т.д. Все эти значения в троичной логике объединены в одно. Снова приходим к выводу, что называть его неопределённостью в большей части случаев неправильно. Но как же тогда его называть?

Я тут недавно подумал: хорошо бы было, чтобы в троичном языке программирования массивы нумеровались от нуля и можно было заполнять их как в одну, так и в другую сторону. Тогда можно будет обращаться к элементам с отрицательным смещением:
for I := -364 to 364
arr[I] := 0;

Возможно, при таком подходе можно будет убыстрить некоторые алгоритмы и, учитывая, что в троичном компьютере не будет беззнаковых чисел, этот подход мне кажется более обоснованным, потому что так можно будет задействовать весь диапазон чисел (для трайта с 6 тритами 3^6 = 729), а не только положительные числа.