Троичный язык программирования T

в 21:21, , рубрики: Сетунь, Си, троичные вычисления, троичные компьютеры, фантазии

1. Введение

Язык T — низкоуровневый язык системного программирования, аналог языка C для сбалансированной троичной системы счисления. В отличие от двоичных языков, где информация кодируется битами (0 и 1), язык T оперирует тритами — трёхзначными разрядами со значениями –1, 0, +1, которые изображаются символами -, 0, +. Синтаксис языка T близок к C, что делает его доступным для программистов, знакомых с классическим C, но при этом он расширен конструкциями, необходимыми для эффективной работы с троичной логикой и арифметикой.

Язык T двуязычен: все ключевые слова имеют английские и русские варианты. Например, if/если, while/пока, for/для, return/возврат, tint/тцел, sizeof/размер. Это позволяет писать программы как на английском, так и на русском языке без использования макросов.

2. Основные понятия

Трит (trit) — минимальная единица информации в языке T. Принимает три значения: –1 (-), 0 (0), +1 (+). В выражениях трит автоматически повышается до типа tint.

Трайт (tryte) — минимальная адресуемая ячейка памяти, состоящая из 6 тритов. Трайт является аналогом байта в двоичных системах. Диапазон значений трайта: от –364 до +364.

Сбалансированная троичная система — система счисления с основанием 3 и цифрами –1, 0, +1. Её ключевое преимущество перед несбалансированной троичной системой (цифры 0, 1, 2) — естественное представление отрицательных чисел без отдельного знакового разряда. Например, число –5 в сбалансированной троичной системе записывается как -++ (что означает –1·9 + 1·3 + 1·1 = –9 + 3 + 1 = –5), а число +5 — как +-- (1·9 – 1·3 – 1·1 = 9 – 3 – 1 = 5).

3. Система типов

3.1. Целочисленные типы

Все целые типы кратны трайту и используют сбалансированное представление:

Тип

Тритов

Трайтов

Диапазон (сбалансированный)

tryte

6

1

–364 … +364

tshort

12

2

–265 720 … +265 720

tint

18

3

–193 710 244 … +193 710 244

tlong

36

6

–7,6·10¹⁶ … +7,6·10¹⁶

tlong long

54

9

–2,0·10²⁵ … +2,0·10²⁵

  • tryte (трайт) — 6 тритов, 1 трайт. Синоним char-подобного типа. Диапазон: –364 … +364.

  • tshort (ткоротк) — короткое целое, 12 тритов, 2 трайта. Диапазон: –265 720 … +265 720.

  • tint (тцел) — стандартное целое, 18 тритов, 3 трайта. Диапазон: –193 710 244 … +193 710 244.

  • tlong (тдлин) — длинное целое, 36 тритов, 6 трайтов. Диапазон: ±7,6·10¹⁶.

  • tlong long (тдлинлонг) — сверхдлинное целое, 54 трита, 9 трайтов. Диапазон: ±2,0·10²⁵.

Оператор sizeof (размер) возвращает размер типа в трайтах:

sizeof(tryte)   == 1    размер(трайт)   == 1
sizeof(tshort)  == 2    размер(ткоротк) == 2
sizeof(tint)    == 3    размер(тцел)    == 3
sizeof(tlong)   == 6    размер(тдлин)   == 6
sizeof(tdouble) == 6    размер(тдвойн)  == 6

3.2. Вещественные типы

  • tfloat (твещ) — вещественный тип, 18 тритов (3 трайта). Формат: 6 тритов порядка, 12 тритов мантиссы. Смещение порядка (bias) = 182.

  • tdouble (тдвойн) — вещественный тип двойной точности, 36 тритов (6 трайтов). Формат: 8 тритов порядка, 28 тритов мантиссы. Смещение порядка (bias) = 3280.

Формат вещественного числа: значение = (скрытый_трит . m₁…mₚ) × 3^(E−bias). Скрытый трит не хранится, мантисса нормализована. Специальные значения: ноль (порядок = 0, мантисса = 0), бесконечность (порядок = макс., мантисса = 0), NaN (порядок = макс., мантисса ≠ 0).

3.3. Логический тип

tril (трил) — логический трит для трёхзначной логики:

  • true (истина) = +1

  • maybe (может) = 0

  • false (ложь) = –1

Логические операторы && (И) и || (ИЛИ) реализуют трёхзначную логику: && — минимум, || — максимум. Оба операнда вычисляются всегда (короткого замыкания нет).

3.4. Трит

trit (трит) — одиночный трит со значениями –1, 0, +1. В выражениях автоматически повышается до tint. Символьные константы '+', '0', '-' имеют тип trit и значения +1, 0, –1 соответственно. Любой другой символ (например, 'A') имеет тип tryte и хранит его код.

4. Литералы

4.1. Десятичные целые литералы

Десятичные литералы требуют обязательного суффикса, определяющего тип:

Суффикс

Тип

Примеры

y

tryte

42y, -100y, 0y

s

tshort

1000s, -50000s

t

tint

42t, -100t, 0t

tl

tlong

100000tl, -5000000tl

tll

tlong long

1000000tll

4.2. Сбалансированные троичные литералы

Префикс 0t, затем троичные цифры -, 0, +. Допускается символ _ для группировки:

  • 0t+-0_+- — 6 тритов с группировкой

  • 0t+++_+++ — максимальное положительное значение tryte (+364)

  • 0t---_--- — минимальное отрицательное значение tryte (–364)

  • 0t0 — явный троичный ноль

4.3. 27-ричные литералы (tryx)

Префикс 0y, затем цифры, каждая из которых кодирует 3 трита. Алфавит (тройки от --- до +++):

N O P Q R S T U V    (--- … -++)
W X Y Z 0 1 2 3 4    (0-- … 0++)
5 6 7 8 9 A B C D    (+-- … +++)

Допустим нижний регистр. Число цифр = (триты типа) / 3. Примеры:

  • 0yNN — минимальное значение tryte (–364)

  • 0yDD — максимальное значение tryte (+364)

  • 0y000000 — ноль типа tint

Каждая tryx-цифра представляет собой одну из 27 возможных комбинаций трёх тритов. Например, цифра N соответствует --- (все три трита равны –1), цифра D соответствует +++ (все три трита равны +1), цифра 0 соответствует 000 (все три трита равны 0). Таким образом, tryx-запись позволяет компактно представлять троичные числа: для типа tint (18 тритов) требуется всего 6 tryx-цифр вместо 18 троичных цифр.

4.4. 9-ричные литералы (ninary)

Префикс 0n, затем цифры, каждая из которых кодирует 2 трита. Алфавит (старший, младший):

W (--)  X (-0)  Y (-+)  Z (0-)
0 (00)  1 (0+)  2 (+-)  3 (+0)  4 (++)

Число цифр = (триты типа) / 2. Примеры:

  • 0nW04 — последовательность -- 00 ++

  • 0n000 — ноль типа tryte

9-ричная (ninary) запись занимает промежуточное положение между троичной и 27-ричной: каждая цифра кодирует 2 трита, что даёт 9 возможных комбинаций. Для типа tryte (6 тритов) требуется 3 ninary-цифры, для tint (18 тритов) — 9 цифр.

4.5. Вещественные литералы

Десятичная запись: целая и дробная часть через точку, опционально экспонента e. Суффикс ftfloat, d или без суффикса — tdouble. Примеры: 3.14, -0.001f, 1.0e+2d.

Троичная запись: префикс 0t, мантисса с точкой, e, порядок. Суффикс f или d обязателен. Примеры: 0t+.-0+0e+0f (tfloat), 0t-.0++_---e-+d (tdouble).

5. Управляющие конструкции

5.1. Трёхветвевой if

К традиционным ветвям if и else добавлена опциональная ветвь maybe, которая может следовать в любом порядке относительно else:

if (condition)
    print("истинаn");
maybe
    print("может бытьn");
else
    print("ложьn");

Если ветвь maybe опущена, то при значении условия maybe управление переходит к следующей после if инструкции.

5.2. Тринарный условный оператор

Тринарный оператор ?? :? :! позволяет выбрать одну из трёх ветвей в зависимости от трёхзначного условия:

условие ?? выраж_истина :? выраж_может :! выраж_ложь

Пример:

tril flag = maybe;
tryte x = (flag == true) ?? 10y :? 0y :! -10y;

Все три выражения вычисляются. Тип результата — общий тип трёх выражений.

5.3. Циклы и переключатели

Циклы while, for, do-while работают как в C, но условие проверяется на равенство true. При maybe или false цикл прерывается. Переключатель switch также аналогичен C, но тип tril не может быть использован непосредственно — его нужно явно преобразовать в целое.

6. Потритовые операторы

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

  • & — потритовый минимум: каждый трит результата равен минимуму соответствующих тритов операндов. + & 0 = 0, + & - = -, 0 & - = -.

  • | — потритовый максимум: каждый трит результата равен максимуму. + | 0 = +, + | - = +, 0 | - = 0.

  • ^ — потритовая сумма по модулю 3 без переноса: + ^ + = - (1 + 1 = 2 → –1), - ^ - = + (–1 + –1 = –2 → +1), + ^ 0 = +, + ^ - = 0.

  • ~ — потритовое отрицание: каждый трит меняет знак. ~+ = -, ~- = +, ~0 = 0.

Эти операторы применимы только к целым типам. Сдвиги << и >> выполняют умножение и деление на 3ⁿ соответственно.

7. Преобразования типов

Неявные преобразования:

  • trit автоматически повышается до tint в выражениях.

  • В операциях с разными целыми типами меньший тип повышается до большего: tinttlongtlong long.

  • Целые типы преобразуются в вещественные при смешанных операциях: tinttfloattdouble.

  • tril неявно преобразуется в trit и наоборот.

Явные преобразования (приведение типа):

tfloat f = (tfloat) a;   // tint → tfloat
tint x = (tint) 3.14;    // tdouble → tint (отбрасывание дробной части)

При присваивании более широкого типа узкому значение усекается до нужного количества тритов.

8. Структуры, объединения и тритовые поля

Язык T поддерживает структуры (struct/структура), объединения (union/объединение) и перечисления (enum/перечисление). Структуры могут содержать тритовые поля — аналог битовых полей в C, но упаковка ведётся по тритам, а не по битам. Тритовые поля позволяют эффективно упаковывать данные, когда требуется хранить значения, не кратные трайту.

9. Стандартная библиотека

Стандартная библиотека языка T адаптирована для троичных типов:

  • <tio.h> — ввод-вывод: tprintf, tscanf, tfopen, tgetc, tputc, printbal, printtryte, printtril, printfloat, printdouble.

  • <tstring.h> — строковые операции: tstrlen, tstrcpy, tstrcat, tstrcmp, tstrchr.

  • <tmath.h> — математические функции: tsin, tcos, tsqrt, tabs, tfabs, tmin, tmax, tfloor, tceil.

  • <tstdlib.h> — общего назначения: tmalloc, tfree, trealloc, tcalloc, texit, trand, tsystem.

  • <tctype.h> — классификация символов: tisdigit, tisspace, tistrit, tisalpha, toupper, tolower.

  • <tstdarg.h> — списки аргументов переменной длины: tva_list, tva_start, tva_arg, tva_end.

  • <tassert.h> — диагностика: tassert.

  • <tsetjmp.h> — нелокальные переходы: tsetjmp, tlongjmp.

  • <tsignal.h> — обработка сигналов: tsignal, traise.

  • <ttime.h> — дата и время: ttime, tclock, tdifftime.

  • <tlimits.h> — пределы целых типов: TINT_MIN/TINT_MAX (–193 710 244/+193 710 244), TLONG_MIN/TLONG_MAX (±7,6·10¹⁶), TLLONG_MIN/TLLONG_MAX (±2,0·10²⁵).

  • <tfloat.h> — параметры вещественных типов: TFLT_MANT_DIG (12), TDBL_MANT_DIG (28).

10. Заключение

Язык T представляет собой законченную троичную альтернативу языку C, сохраняя его философию низкоуровневого системного программирования и одновременно расширяя возможности за счёт трёхзначной логики, сбалансированной арифметики и естественной поддержки троичных типов данных. Ключевые отличия от C: обязательные суффиксы размеров у десятичных литералов, 9-ричное и 27-ричное представление чисел, потритовые операции вместо битовых, трёхветвевые условные конструкции, тринарный оператор с тремя ветвями, трёхзначная логика и двуязычный синтаксис (английский/русский). Язык T предназначен для троичных вычислительных систем и может быть реализован как на физическом троичном оборудовании, так и в режиме эмуляции на традиционных двоичных компьютерах.

11. Спецификация EBNF

Полная грамматика языка T в нотации EBNF (трайт = 6 тритов, сбалансированная троичная система):

EBNF грамматика языка T

(* ============================================================ Полная EBNF-грамматика языка T (трайт = 6 тритов, сбалансированная троичная система) ============================================================ *)

(* ----------------------------------------------------------

  1. Лексическая структура ---------------------------------------------------------- *) trit_digit = “-” | “0” | “+” .

(* Идентификаторы: латиница + кириллица *) identifier = ( letter | “" ) { letter | digit | "” } . letter = latin_letter | cyrillic_letter . latin_letter = “A”…“Z” | “a”…“z” . cyrillic_letter = “А”…“Я” | “а”…“я” | “Ё” | “ё” . digit = “0”…“9” .

(* Десятичные целые литералы (суффикс определяет тип) *) decimal_suffix = “y” | “s” | “t” | “tl” | “tll” . decimal_literal = [ “+” | “-” ] digit { digit } decimal_suffix .

(* Сбалансированные троичные литералы *) balanced_prefix = “0t” . balanced_digits = trit_digit { trit_digit } [ “_” trit_digit ] . balanced_literal = balanced_prefix balanced_digits .

(* 27-ричные литералы (tryx): тройки тритов *) tryx_prefix = “0y” . tryx_digit = “N” | “O” | “P” | “Q” | “R” | “S” | “T” | “U” | “V” | “W” | “X” | “Y” | “Z” | “0” | “1” | “2” | “3” | “4” | “5” | “6” | “7” | “8” | “9” | “A” | “B” | “C” | “D” | “n” | “o” | “p” | “q” | “r” | “s” | “t” | “u” | “v” | “w” | “x” | “y” | “z” | “a” | “b” | “c” | “d” . tryx_literal = tryx_prefix tryx_digit { tryx_digit } .

(* 9-ричные литералы: пары тритов *) nine_prefix = “0n” . nine_digit = “W” | “X” | “Y” | “Z” | “0” | “1” | “2” | “3” | “4” | “w” | “x” | “y” | “z” . nine_literal = nine_prefix nine_digit { nine_digit } .

integer_literal = decimal_literal | balanced_literal | tryx_literal | nine_literal .

(* Вещественные литералы *) float_suffix = “f” | “d” . decimal_float = [ “+” | “-” ] digit { digit } “.” digit { digit } [ “e” [ “+” | “-” ] digit { digit } ] [ float_suffix ] . balanced_float = balanced_prefix mantissa_part “e” exponent_part float_suffix . mantissa_part = trit_digit { trit_digit } [ “_” trit_digit ] “.” trit_digit { trit_digit } . exponent_part = trit_digit { trit_digit } . float_literal = decimal_float | balanced_float .

(* Символьные константы ) char_literal = “'” ( trit_digit | any_character ) “'” . ( Символы ‘+’,‘0’,‘-’ дают тип trit, остальные — tryte *)

(* Строковые литералы *) string_literal = ‘"’ { any_character } ‘"’ .

(* Константы *) true_const = “true” | “истина” . false_const = “false” | “ложь” . maybe_const = “maybe” | “может” . constant = integer_literal | float_literal | char_literal | string_literal | true_const | false_const | maybe_const .

(* ---------------------------------------------------------- 2. Выражения ---------------------------------------------------------- *) primary_expr = identifier | constant | “(” expression “)” .

postfix_expr = primary_expr | postfix_expr “[” expression “]” | postfix_expr “(” [ argument_list ] “)” | postfix_expr “.” identifier | postfix_expr “->” identifier | postfix_expr “++” | postfix_expr “–” . argument_list = expression { “,” expression } .

unary_expr = postfix_expr | “++” unary_expr | “–” unary_expr | unary_operator unary_expr . unary_operator = “+” | “-” | “!” | “~” | “*” | “&” | “sizeof” | “размер” .

multiplicative_expr = unary_expr { ( “*” | “/” | “%” ) unary_expr } . additive_expr = multiplicative_expr { ( “+” | “-” ) multiplicative_expr } . shift_expr = additive_expr { ( “<<” | “>>” ) additive_expr } .

relational_expr = shift_expr { ( “<” | “>” | “<=” | “>=” ) shift_expr } . equality_expr = relational_expr { ( “==” | “!=” ) relational_expr } .

(* Потритовые операторы *) bitwise_and_expr = equality_expr { “&” equality_expr } . bitwise_xor_expr = bitwise_and_expr { “^” bitwise_and_expr } . bitwise_or_expr = bitwise_xor_expr { “|” bitwise_xor_expr } .

logical_and_expr = bitwise_or_expr { “&&” bitwise_or_expr } . logical_or_expr = logical_and_expr { “||” logical_or_expr } .

ternary_expr = logical_or_expr “??” expression “:?” expression “:!” expression .

assignment_expr = ternary_expr | unary_expr assignment_operator assignment_expr . assignment_operator = “=” | “+=” | “-=” | “*=” | “/=” | “%=” | “<<=” | “>>=” | “&=” | “|=” | “^=” . expression = assignment_expr .

(* ---------------------------------------------------------- 3. Объявления ---------------------------------------------------------- ) ( Спецификаторы типов (английские и русские) *) void_type = “void” | “пусто” . tryte_type = “tryte” | “трайт” . tshort_type = “tshort” | “ткоротк” . tint_type = “tint” | “тцел” . tlong_type = “tlong” | “тдлин” . tlong_long_type = “tlong” | “long” | “тдлиндлин” . tfloat_type = “tfloat” | “твещ” . tdouble_type = “tdouble” | “тдвойн” . trit_type = “trit” | “трит” . tril_type = “tril” | “трил” . signed_spec = “signed” | “знак” . unsigned_spec = “unsigned” | “беззнак” .

type_specifier = void_type | tryte_type | tshort_type | tint_type | tlong_type | tlong_long_type | tfloat_type | tdouble_type | trit_type | tril_type | signed_spec | unsigned_spec | struct_or_union_specifier | enum_specifier | typedef_name .

struct_or_union = “struct” | “структура” | “union” | “объединение” . struct_or_union_specifier = struct_or_union [ identifier ] “{” { struct_declaration } “}” | struct_or_union identifier . struct_declaration = type_specifier struct_declarator_list “;” . struct_declarator_list = struct_declarator { “,” struct_declarator } . struct_declarator = declarator | [ declarator ] “:” expression .

enum_kw = “enum” | “перечисление” . enum_specifier = enum_kw [ identifier ] “{” enumerator_list “}” | enum_kw identifier . enumerator_list = enumerator { “,” enumerator } . enumerator = identifier [ “=” expression ] .

type_qualifier = “const” | “конст” | “volatile” | “изменч” .

declaration_specifiers = ( type_specifier | type_qualifier ) { type_specifier | type_qualifier } . declarator = pointer_decl direct_declarator | direct_declarator . direct_declarator = identifier | “(” declarator “)” | direct_declarator “[” [ expression ] “]” | direct_declarator “(” parameter_list “)” | direct_declarator “(” “)” . pointer_decl = “*” [ type_qualifier { type_qualifier } ] [ pointer_decl ] . parameter_list = parameter_declaration { “,” parameter_declaration } . parameter_declaration = declaration_specifiers [ declarator | abstract_declarator ] . abstract_declarator = pointer_decl [ direct_abstract_declarator ] | direct_abstract_declarator . direct_abstract_declarator = “(” abstract_declarator “)” | “[” [ expression ] “]” | “(” [ parameter_list ] “)” . initializer = expression | “{” initializer_list [ “,” ] “}” . initializer_list = initializer { “,” initializer } . declaration = declaration_specifiers [ init_declarator_list ] “;” . init_declarator_list = init_declarator { “,” init_declarator } . init_declarator = declarator [ “=” initializer ] .

(* ---------------------------------------------------------- 4. Операторы ---------------------------------------------------------- *) if_kw = “if” | “если” . maybe_kw = “maybe” | “может” . else_kw = “else” | “иначе” . switch_kw = “switch” | “выбор” . case_kw = “case” | “случай” . default_kw = “default” | “умолчание” . while_kw = “while” | “пока” . do_kw = “do” | “делать” . for_kw = “for” | “для” . continue_kw = “continue” | “продолжить” . break_kw = “break” | “прервать” . return_kw = “return” | “возврат” . goto_kw = “goto” | “перейти” .

statement = expression_statement | compound_statement | selection_statement | switch_statement | labeled_statement | iteration_statement | jump_statement . expression_statement = [ expression ] “;” . compound_statement = “{” { declaration | statement } “}” . selection_statement = if_kw “(” expression “)” statement ( [ maybe_kw statement ] [ else_kw statement ] | [ else_kw statement ] [ maybe_kw statement ] ) . switch_statement = switch_kw “(” expression “)” statement . case_label = case_kw expression “:” . default_label = default_kw “:” . labeled_statement = case_label statement | default_label statement . iteration_statement = while_kw “(” expression “)” statement | do_kw statement while_kw “(” expression “)” “;” | for_kw “(” [ expression ] “;” [ expression ] “;” [ expression ] “)” statement . jump_statement = continue_kw “;” | break_kw “;” | return_kw [ expression ] “;” | goto_kw identifier “;” .

(* ---------------------------------------------------------- 5. Внешние определения ---------------------------------------------------------- *) extern_kw = “extern” | “внеш” . static_kw = “static” | “статич” . auto_kw = “auto” | “авто” . register_kw = “register” | “регистр” . inline_kw = “inline” | “встроен” . typedef_kw = “typedef” | “типрег” .

translation_unit = { external_definition } . external_definition = function_definition | declaration . function_definition = declaration_specifiers declarator [ declaration_list ] compound_statement . declaration_list = { declaration } .

Автор: EntityFX

Источник


https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js