i1GJ0

      что такое умолчательные правила (на примере)
       -- дайте мне пить.
       -- дает стакан воды.
            (не сказал сколько -- по умолчанию 250 мл.
             не сказал что -- по умолчанию вода.)

Системы счисления
~~~~~~~~~~~~~~~~~

десятичная  (арифметика в начальных классах)

  алфавит: ' ' '-' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'

  целые числа: 1. Одна или больше цифр.
               2. Друг от друга числа отделяются пробелом.
               3. Если цифр в числе больше одной, то самая левая цифра
                  не 0. Слева от самой левой цифры можно написать '-' .

троичная по Тюрингу:

  алфавит: ' ' '0' '1'
  целое число: 1. Условимся: самая правая цифра это знак числа.
                  0 , когда число положительное и
                  1 , когда число отрицательное.
               2. Друг от друга числа отделяются пробелом.
               3. Ноль записывается одной цифрой ('0')
               3. Если цифр в числе больше одной, то самая левая цифра
                  не 0.

двоичная:

  алфавит: '0' '1'
  целое число: 1. Условимся: все числа одинаковой длины.
                  Если самый левый бит '1' то число отрицательное
                  в дополнительном коде (дигиталка).

На сегодня повсеместно победила двоичная система:

  1. Железо проще чем для 3-ной, но работать с информацией сложнее.
  2. Дешевле.
  3. Быстрее работает.
  4. Программистам нужно платить больше
     (понятия, непривычные в повседневной жизни:
      переполнения, польская запись, арифметика NaN,..),
      но при массовом производстве все-равно выгоднее.

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

  + целые беззнаковые числа длиной в один байт:    0..255
  + целые числа со знаком длиной в один байт:   -128..127.

Операции
~~~~~~~~

  1. Арифметика:  +  -  *  /  %

  2. Побитная логика:  ~  &  |  ^

  3. Логика:  !  &&  ||

  4. Сравнения:  <  <= == != >= >

  5. Сдвиги:  << >>

  6. Если:  ?:

  7. Присваивание: =

Можно скачать "тренажер\" на Logisim'е
(Downloads, Папка LoMi-ixx.rar, файл two2ten.circ)

Теперь подробнее о каждой операции.

Арифметическое сложение '+'
---------------------------

Как в начальной школе, но есть неприятности. Результат должен помещаться в условленный размер (скажем, 8 бит). Поэтому считать в двоичной системе, знать дополнительный код. Короче, 100 + 31 = -125 :)

                11111
Почему?  100 -> 01100100
        +
          31 -> 00011111
        =
                10000011
        2c*
               -01111101 -> -(64+32+16+8+4+1) = -125

<< 2c -- дополнительный код. если левый бит 1, число отрицательное.
<< справа налево: переписываем число пока не попадется единица.
<< переписываем и ее, дальше все биты инвертируем. Еще примеры:

   10000000
  -10000000 -> -(128+0+0+0+0+0+0+0) = -128

Арифметическое вычитание '-'
----------------------------

Справедливо все, что сказано о сложении, короче 100 - -100 = -56

Арифметическое умножение '*'
----------------------------

Множимое и множитель целые неотрицательные 0..255 . Результат длиннее, может занять два байта 0..65025

Арифметическое деление: целая часть '/' и остаток %
---------------------------------------------------

  29 делить на 8 равно 3.625 целая часть 3 остаток 29-3*8 = 5

  29 / 8 = 3
  29 % 8 = 5

Побитная инверсия '~'
---------------------

  ~123 = 132         01111011              x   ~x
                   ~                       0    1
                     10000100 -> 132       1    0

Побитное и '&'
--------------

   107 & 242 = 98    01101011              x  y  x&y
                   &                       0  0  0
                     11110010              0  1  0
                   =                       1  0  0
                     01100010 -> 98        1  1  1

Побитное или '|'
----------------

  144 | 41 = 185     10010000              x  y  x|y
                   |                       0  0  0
                     00101001              0  1  1
                   =                       1  0  1
                     10111001 -> 185       1  1  1

Побитное исключающее или '^'
----------------------------

  100 ^ 167 = 195    01100100              x  y  x&y
                   ^                       0  0  0
                     10100111              0  1  1
                   =                       1  0  1
                     11000011 -> 195       1  1  0

Логика && || ! (and or not)
---------------------------

'false' это 0, 'true' -- все остальное (все, что не false). Если 'true' возникает как новое число, то true это 1

    19 && 95 = 1
   123 ||  0 = 1
  !172       = 0
    !0       = 1

Сравнения
---------

Никаких неожиданностей, сравниваем два байта, результат true '1' или false '0' .

Сдвиги '<<' и '>>'
------------------

Бит вылетевший через край теряется. Бит с противоположной стороны 0

  51 << 3 = 152    00110011        51 >> 3 = 6      00110011
                   01100110                         00011001
                   11001100                         00001100
                   10011000 -> 152                  00000110 -> 6

Если '?:'
---------

Если первое число 'true' , то ответ это второе число. Если первое число 'false' , то ответ это третье число.

  16 ? 157 : 70 -> 157
  0 ? 157 : 70 -> 70

Присваивание '='
----------------

Иногда результат нужно сохранить в памяти компьютера. Человеку проще запомнить некоторое название, чем адрес в памяти. Например,

  temperature = 46 - (2 + 5) * 3

Чтобы посчитать выражение, записанное таким образом, нужно видеть его целиком: где скобки; что раньше складывать, умножать или вычитать? (называется "приоритеты операций\"). Около ста лет назад польский математик Ян Лукасевич предложил беcскобочный способ записи выражений.

Чаще используется зеркальный вариант записи, RPN -- reverse polish notation. Из только что рассмотренного примера, temperature:

  46 5 2 + 3 * -

Потренироваться можно на https://www.dcode.fr/reverse-polish-notation

Если говорить "прямым текстом\", то микропроцессоры хмм.. программируют. Так что, теперь займемся программированием.

Приложение А. PLC Instruction List (CodeSys)
--------------------------------------------

ACCUMULATOR - register (CoDeSys..RESULT)

  LD    load var -> accu
  ST    store accu -> var

  S     set variable if DATA is TRUE
  R     reset variable if DATA is TRUE

  AND   accu AND var  ; TRUE AND FALSE -> FALSE
  OR    accu OR  var  ; TRUE OR  FALSE -> TRUE
  XOR   accu XOR var  ; TRUE XOR FALSE -> TRUE
  NOT   accu          ; NOT TRUE       -> FALSE

  ADD   accu + var    ; 7 + 2 = 9
  SUB   accu - var    ; 7 - 2 = 5
  MUL   accu * var    ; 7 * 2 = 14
  DIV   accu / var    ; 7 / 2 =  3
  MOD   accu % var    ; 7 % 2 =  1

  LT    accu < var    ; 7 < 2  = FALSE
  LE    accu <= var   ; 7 <= 2 = FALSE
  QE    accu == var   ; 7 == 2 = FALSE
  NE    accu <> var   ; 7 <> 2 = TRUE
  GE    accu >= var   ; 7 >= 2 = TRUE
  GT    accu > var    ; 7 > 2  = TRUE

  SHL   accu << var   ; 7 << 2 = 1C
  SHR   accu >> var   ; 7 >> 2 = 1

  JMP   label
  CAL   name( named args)
  RET

