Редактирование: Языки программирования, 06 лекция (от 21 сентября)

Материал из eSyr's wiki.

Внимание: Вы не представились системе. Ваш IP-адрес будет записан в историю изменений этой страницы.

Правка может быть отменена. Пожалуйста, просмотрите сравнение версий, чтобы убедиться, что это именно те изменения, которые вас интересуют, и нажмите «Записать страницу», чтобы изменения вступили в силу.

[[Языки программирования, 05 лекция (от 19 сентября)|Предыдущая лекция]] | [[Языки программирования, 07 лекция (от 26 сентября)|Следующая лекция]]

=Часть 1. Основные понятия  традиционных процедурных ЯП=
==Глава 1. Скалярный базис.==
===Пункт 2. Целые типы и проблема представления беззнаковых чисел (продолжение)===

Наличие беззнакового типа байт ничему не противоречит.
{|
 !Размер
 ![[Java]]
 ![[Oberon]]
 ![[C#]]
 |-
 |1
 |byte
 |BYTE
 |sbyte
 |byte
 |-
 |2
 |short
 |SHORTINT
 |short
 |ushort
 |-
 |4
 |int
 |INTEGER
 |int
 |uint
 |-
 |8
 |long
 |LONGINT
 |long
 |ulong
 |}

В Обероне разрешено включение типов. 
[[Modula|Modula-2]] ориентирована на 16-битные машины, посему лишний бит не был лишним. 
Горизонтальные неявные преобразования в C# не разрешены.

Синтаксис преобразования  типа. Эволюция:
{|
 ![[C]]
 |exp
 |-
 ![[Algol]]
 |T(exp)
 |-
 ![[Pascal]]
 |T(exp)
 |-
 ![[C++]]
 |T(exp), (T)exp, static_cast&lt;T&gt;(exp)
 |-
 ![[C#]]
 |(T)exp
 |-
 ![[Java]]
 |(T)exp
 |}

В современных языках  больше внимания уделяется надёжности.

Беззнаковые типы должны  вымирать.

Язык с авторской позиции:  включать или не включать определяется  технологическими соображениями. Если  есть адресная арифметика, то они  требуется. С авторской позиции язык&nbsp;&mdash; совокупность компромиссов, и все  изменения волнами расходятся по языку.

В '''Java''''e исключили беззнаковые типы, но  есть ещё операция сдвига, которая бывает  разная&nbsp;&mdash; арифметическая (знаковый)  и логическая (беззнаковый), посему в  Java'e появились две операции сдвига  вправо: &gt;&gt; и &gt;&gt;&gt;. Размерность определяется  исключительно спецификацией Java-машины.  (?)

В '''Delphi''' зафиксированы  размеры типов, потому что Delphi&nbsp;&mdash; язык синтетический, должен учитывать  совместимость с предыдущим кодом и  привязана к Windows на платформе Intel.

В '''C''' и '''С++''' не были  зафиксированы размеры, так как в это  время было разнообразие различных  архитектур. При фиксировании int уменьшается  эффективность. K&amp;R  C появился в [[1972]] году.

===Тип данных===
Hовизна языка [[Ada]] в  появлении подтипов.

*[[Pascal]]: Несовместимые типы  данных.
 ('''Pascal''')
 type
 LENGTH=INTEGER;
 AREA=INTEGER;

*[[C]]: Один и тот же тип данных.
 ('''C''')
 typedef  int LENGTH; 
 typedef  int AREA;

*[[Ada]]: Разные типы данных, не совместимые друг с другом. Это очень правильно.
 ('''Ada''')
 type  length is '''new''' INTEGER range 0..MAX_INT;
 type  area is '''new''' INTEGER range 0..MAX_INT.

subtype ...&nbsp;— подтип, совместимый со старым
С этой точки зрения вопрос о знаковости-беззнаковости решается очень просто. Любая операция преобразования контролируемая. 
Аналогичным образом решается проблема генерации ошибки. (?)
 ('''Ada''')
 subtype intshort is INTEGER modulo 65536;
Никакого в этом случае переполнения быть не может, так как все опреации выполняются по модулю 216.
Много на языке Ada возложено на плечи компилятора, но семантика определена весьма точно, что способствует переносимости. Может меняться эффективность. Программист имеет право управлять, как вопросами представления, так и надёжности, знаковости. И можно писать полностью переносимые программы, что на Си делать затруднительно.

Современные  языки выбрали более простой подход, так  как проблема переносимости не стоит  так остро.

===Пункт 3. Вещественные типы===
Компьютеры дискретны, поэтому реализация вычислений должна подразумевать конечную точность.

Два решения:
*Плавающая точка&nbsp;— относительная погрешность вычислений
*Фиксированная точка&nbsp;— абсолютная погрешность вычислений

====Плавающая точка====
 X=&plusmn;Mantissa*BasePower&nbsp;— представление с плавающей точкой. 
Плюс&nbsp;— можно представлять и маленькие числа, и большие. Платим относительной точностью. 
Пусть 4 байта разбиты следующим образом: 1 бит знак, 23 мантисса, 8 степень. Такой формат числа с плавающей точкой стандартизован в '''IEEE 754'''. Стандарты IEEE активно внедряются, так как государство свой нос туда не суёт. Зафиксируем значение порядка равным 0. Можно представить от &frac12; до 1, и на нём 223 чисел, при 1 от 1 до 2 тоже 223 чисел, и т. д. При каких значениях порядка дельта становится равной единице? При 23. 223&nbsp;— чуть более 8000000 (8388608).

Иногда  нужна абсолютная точность вычислений,  например, в финансах. C точки зрения вещественных вычисления  Ada наиболее адекватный язык. Как решена  проблема с управляемой точностью в  плавающих типах: задание количества  знаков после запятой.
 ('''Ada''')
 Type  REAL is digits 6;
 type  T is digits D;

Модельные числа&nbsp;— представлены в виде плавающих чисел и обеспечивают соответствующую точность. Хранятся в виде знак, мантисса, порядок. Требуется [log2(D)]+1 битов для D знаков, соответствующим образом подбирается порядок. Подбирается стандартный тип для обеспечения соотвующей точности. Если стандартного типа не было, то по стандарту [[1983]] года компилятор должен программно эмулировать работу с ними.

====Фиксированная точка====
 ('''Ada''')
 Type  T is delta H range L..R
В  современных языках программирования  всё совершенно не так. В C только  сказано, что float не длиннее double, а double не  длиннее long double. Основной тип C&nbsp;—  double, и все вычисления производятся в  double.

*Пример из жизни, зачем нужен %f: студент-вечерник дал лектору задачу, спросил, почему сыпется:
 ('''C''')
 double d, f;
 scanf(&laquo;%f&raquo;,&amp;d);
 d=d/2;
Как только начинаются вычисления на введённым d, программа падает. Так как %f&nbsp;— формат ввода для float.

В Java и C# '''фиксированы''' float - 4, double - 8.

в  Java сказано, что действия на числами с  плавающей точкой работают по стандарту  IEEE 754, в C# примерно то же самое. Ошибкой  деление на ноль не считается, но  результатом подобного действия является  NaN или Inf.

===Пункт 4. Логические типы===
C и C++ выпадали из общей канвы, но в [[1990]] году появился тип bool, и в C99 появился тип _bool, который описан в &lt;bool.h&gt; вместе с константами true и false. 
C у программистов это C89. Аналогично с FORTRAN, где большинство программирует на F77.
Логический тип данных есть во всех ЯП. Называется или BOOLEAN, или bool. В современных языках есть отдельный булевский тип, не совместимый с другими.

Пожалуйста, обратите внимание, что все ваши добавления могут быть отредактированы или удалены другими участниками. Если вы не хотите, чтобы кто-либо изменял ваши тексты, не помещайте их сюда.
Вы также подтверждаете, что являетесь автором вносимых дополнений, или скопировали их из источника, допускающего свободное распространение и изменение своего содержимого (см. eSyr's_wiki:Авторское право).
НЕ РАЗМЕЩАЙТЕ БЕЗ РАЗРЕШЕНИЯ ОХРАНЯЕМЫЕ АВТОРСКИМ ПРАВОМ МАТЕРИАЛЫ!

Описание изменений:

Отменить | Справка по редактированию (в новом окне)

Шаблоны, использованные на этой странице:

Получено с http://esyr.org/wiki/%D0%AF%D0%B7%D1%8B%D0%BA%D0%B8_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F%2C_06_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D1%8F_%28%D0%BE%D1%82_21_%D1%81%D0%B5%D0%BD%D1%82%D1%8F%D0%B1%D1%80%D1%8F%29

@@ Строка 120: / Строка 120: @@
  X=&plusmn;Mantissa*Base<sup>Power</sup>&nbsp;—   представление с плавающей точкой.
 <p>Плюс&nbsp;—   можно представлять и маленькие числа,  и большие. Платим относительной точностью. </p>
-Пусть 4 байта разбиты  следующим образом: 1 бит знак, 23 мантисса,  8 степень. Такой  формат  числа с плавающей точкой  стандартизован в '''IEEE 754'''. Стандарты IEEE  активно внедряются, так как государство  свой нос туда не суёт. Зафиксируем  значение порядка равным 0. Можно  представить от &frac12; до 1, и на нём 2<sup>23</sup>  чисел, при 1 от 1 до 2 тоже 2<sup>23</sup> чисел,  и т. д. При каких значениях порядка дельта  становится равной единице? При 23. 2<sup>23</sup>&nbsp;—   чуть более 8000000 (8388608).
+Пусть 4 байта разбиты  следующим образом: 1 бит знак, 23 мантисса,  8 степень. Такой  формат  числа с плавающей точкой  стандартизован в '''IEEE 754'''. Стандарты IEEE  активно внедряются, так как государство  свой нос туда не суёт. Зафиксируем  значение порядка равным 0. Можно  представить от &frac12; до 1, и на нём 223  чисел, при 1 от 1 до 2 тоже 223 чисел,  и т. д. При каких значениях порядка дельта  становится равной единице? При 23. 2<sup>23</sup>&nbsp;—   чуть более 8000000 (8388608).
 Иногда  нужна абсолютная точность вычислений,  например, в финансах. C точки зрения вещественных вычисления  Ada наиболее адекватный язык. Как решена  проблема с управляемой точностью в  плавающих типах: задание количества  знаков после запятой.
@@ Строка 129: / Строка 129: @@
 <p>Модельные  числа&nbsp;— представлены в виде плавающих  чисел и обеспечивают соответствующую  точность. Хранятся в виде знак, мантисса,  порядок. Требуется [log<sub>2</sub>(D)]+1 битов для D  знаков, соответствующим образом  подбирается порядок. Подбирается стандартный тип для обеспечения соотвующей точности. Если стандартного типа не было, то по стандарту [[1983]] года компилятор должен программно эмулировать работу с ними.</p>
 ====Фиксированная точка====

Редактирование: Языки программирования, 06 лекция (от 21 сентября)

Материал из eSyr's wiki.

Просмотры

Личные инструменты

Навигация

инструменты

Разделы

Спецкурсы

9 семестр

7 семестр

5 семестр

3 семестр

Поиск

Инструменты