Какие из предложенных переменных имеют тип real

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

В языке Паскаль существует несколько типов для представления действительных (вещественных) чисел. Чаще всего используется тип Real.

Вещественные типы в Pascal

Число цифр определяет точность, с которой будет храниться вещественное число. Например, для Real разрядность мантиссы может составлять не более восьми десятичных знаков. Тип Comp содержит только целые значения, которые представляются в вычислениях как вещественные.

Над действительными числами выполнимы операции сложения (+), вычитания (-), умножения (*) и деления (/). Результатом этих операций является также действительное число. Даже если хотя бы один из операндов вещественный, то результат этих операций также будет вещественным.

Операция деления (/) дает вещественный результат и в случае двух целых операндов. Например, 6 / 2 = 3.0.

Для действительных чисел допустимы такие же операции отношения (сравнения), что и для целых чисел.

Стандартная функция abs(x) – модуль x – от целого аргумента дает целый результат, а от вещественного – вещественный, как и sqr(x) – квадрат x .

Функции, которые дают вещественный результат, как для вещественного, так и для целого аргумента:

• sin(x) – синус x ( x в радианах),
• cos(x) – косинус x ( x в радианах),
• ln(x) – натуральный логарифм x ,
• exp(x) – экспонента x ,
• sqrt(x) – корень квадратный из x ,
• arctan(x) – арктангенс x

Функция int возвращает в виде действительного значения целую часть аргумента, frac возвращает дробную часть аргумента.

var x: real; begin x := 4.7389; writeln(x:10:4); writeln(int(x):10:4); writeln(frac(x):10:4); end.

 4.7389 4.0000 0.7389

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

Функция random без аргументов возвращает равномерно распределенное случайное число от 0 до 1.

Не имеющая аргументов функция pi возвращает число Пифагора.

Нельзя использовать переменные и константы вещественного типа:

• в функциях pred, succ, ord;
• в качестве индексов массивов;
• в операторах передачи управления в качестве меток.

#4 Real Вещественный тип данных в Паскаль. Неявное приведение типа. Примеры

Тип Real служит для описания и хранения данных, являющихся вещественными числами.

Переменные типа Real

Переменные типа real могут быть объявлены стандартным способом (подобно integer):

var a, b: real;

Таким переменным можно присваивать литералы вещественных чисел:

var a, b: real; begin a := 2.5; b := 2.0; end.

А также результаты любых арифметических выражений:

var a, b: real; begin a := 2.5; b := a/2 + a*3*2.0; // запоминаем результат выражения end.

Сравнение с Real с Integer

Выражения, возвращающие Integer

Если значение арифметического выражения присваивается переменной типа integer, то в него должны входить только:

• целочисленные литералы
• или целочисленные переменные.
• Над указанными операндами должны выполняться операции (только эти — без операции деления):
  1. $+$ суммы (сложения)
  2. $-$ разности (вычитание)
  3. $*$ произведения (умножение)

Выражения, возвращающие Real

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

1. $+$ суммы (сложения)
2. $-$ разности (вычитание)
3. $*$ произведения (умножение)
4. $/$ деление («отношение»)

Можно сказать что тип, который возвращается выражением (тип его результата) определяется двумя моментами:

1. типом операций (допустимые перечислены выше)
2. типом операндов

Неявное приведение (преобразование) типа

Неявное приведение типа — это процесс преобразования типа без каких-то особо записанных в коде инструкций, которые бы явно указывали на то, что выполняется преобразование.

Когда неявное приведение имеет место быть

Неявное приведение типа возможно в двух случаях:

В ходе операции присваивания — когда переменной типа real присваивается любое значение типа integer.
Например:

var a : real; begin a := 7;

О втором случае поговорим подробнее.

Если в арифметическом выражении присутствуют целые числа (переменные, литералы или результаты подвыражений типа integer) и эти числа участвуют в одной операции с типом real, то:

1. сначала целые числа будут приведены Паскалем к типу real (так как real может хранить любые данные типа integer, а обратное не верно)
2. а затем уже будет вычислен результат арифметической операции, который тоже будет иметь тип real

Пусть у нас есть выражение:

a : real; begin a = 5 + 2.0; // запоминаем результат выражения в переменную

— этом случае вычисления будут проходить так («под капотом» языка Паскаль):

5 + 2.0 = 5.0 + 2.0 = 7.0 // получили число 7, но типа real

— знание этой особенности позволяет правильно определить тип переменной для хранения результата выражения.

Что к чему приводится неявно

Если в арифметических выражениях если неявное приведение типа имеет место быть, то это всегда приведения integer к real как к более широкому и универсальному классу чисел.

Рассмотрим разные выражения и прокомментируем когда происходит неявное приведение типа, а когда нет и почему:

6 + 3.3 < -- неявное приведения типа происходит, так как второй операнд имеет вещественный тип, а потому первый будет приведён к 6.0, а только потом вычислится сумма>4 + 8 < -- без неявного приведения -- оба операнда типа integer, сумма тоже типа integer>10 — 3/7 < -- неявное приведения типа происходит, так как второй операнд (результат подвыражения 3/7) имеет вещественный тип (3/7 -- это дробь примерно равная 0.4285714. ), а потому первый будет приведён к вещественному типу и станет = 10.0, а только потом вычислится разность>9.0 + 5 3 + 78

Присваивание несовместных типов. Что и чему можно присваивать

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

Рассмотрим примеры присваивания переменным значений с комментариями, показывающими в каких строках ошибка:

var a,b : integer; begin a := 2; // справа и слева integer a := ‘2’; // ОШИБКА: справа символьный литерал, а слева integer b := 4; // справа и слева integer a := b+5; // справа и слева integer b := ‘123’; // ОШИБКА: справа строковый литерал, а слева integer a := b+5*2; // справа и слева integer a := b+5/2;

Вывод вещественных чисел на экран

Переменные, литералы и результаты выражений типа real можно выводить точно также как и целые числа (их переменные, литералы и выражения).

В некоторых реализациях Паскаля, при выводе на экран может использоваться экспоненциальная форма записи числа, то есть дробное число записывается (две особенности):

1. в виде некоторого числа (обычно с одной цифрой в целой части), умноженного на $10$ в какой-то степени (вещественное число всегда подразумевается обладающим дробной частью, просто иногда она равна нулю, тогда число называют целым).
2. вместо множителя $10$ используют букву $E$.

Примеры экспоненциальной записи чисел

• Так, например число $125.35$:
  $$125.35 = 1.2535 * 100 = 1.2535 * 10^$$
  в экспоненциальной форме может выглядеть так:

1.2535E2

5.567E-3

Разбор задач

Пример №1

Пусть есть задача:

Выведите на экран произведение чисел $5$ и $7.3$

Самое простое решение:

begin writeln(5*7.3); // выводим произведение литералов end.

Хотя по хорошему выводить данные с пояснениями, например используя в качестве первого аргумента литерал:

begin writeln('5*7.3 = ', 5*7.3); // выводим произведение литералов end.

Или пример с выводом произведения переменных:

var a: integer; // используем целый тип, так как 5 целое b: real; // 7.3 -- вещественное число, а потому объявляем её тип как real begin a := 5; b := 7.3; writeln('otvet =', a*b); // выводим произведение переменных end.

— тут вторым аргументом процедуры writeln() оказывается арифметическое выражение.

Ну и наконец, если требуется дополнительно записать результат арифметического выражения в переменную и уже потом вывести её значение, то:

var a: integer; // используем целый тип, так как 5 целое b: real; < мы будем записывать сюда 7.3 -- вещественное число, а потому объявляем её тип как real >c: real; // для результата begin a := 5; b := 7.3; c := a*b; // сравниваем значения переменных и записываем результат в переменную "с" writeln('otvet =', c); // выводим значение переменной на экран end.

Пример №2

Пусть есть задача:

Присвойте трем переменных значения $34$, $36.7$ и $7.3$, в четвертую переменную запишите разность между произведением первой и второй переменной и суммой второй и третей и выведете её значение на экран.

var a :integer; // для 34 достаточно типа integer b, c : real; // вторая и третья (дробные числа) d : real; // сюда запишем результат begin //для начала выполним присваивания по условию задачи a := 34; b := 36.7; c := 7.3; d := a * b - (b + c); // "разность между произведением первой и второй переменной и суммой второй и третей" writeln(d); // "и выведете её значение на экран" writeln('otvet: ', d); // то же самое, но c пояснением end.

Для переменной $d$ нам пришлось использовать тип real, так как выражении:

a * b - (b + c)

две переменные были вещественного типа, а значит переменная $a$ тоже была бы неявно приведена к вещественному типу (а её значение 34 к 34.0) и результат выражения имел вещественный тип, а присваивать результат вещественного типа переменной целого типа нельзя (об этому говорилось в этом уроке выше и в предыдущем уроке), как как в этом случае неявное преобразование для присваивания не сработает (см. выше первый случай когда имеет место быть неявное преобразование типов).

Видео-пояснения

Для данного урока есть следующие видео:

Вопросы & Задачи

Теоретические вопросы:

1. Что такое операнд? Приведите примеры операндов и операций.
2. Для чего нужен тип real?
3. Что такое неявное приведение типа и когда оно работает?
4. Происходит ли приведение типа в выражениях (по каждому ответьте отдельно):

5 + 2.3 5 + 2/4 4 + 2 8.0 + 3 8 + 3

• 0.00045
• 154567.34
• 2.345

Подробней о real и integer

В одном из прошлых уроков, я уже рассказывал об особенностях числовых типов real и integer. В этом уроке рассмотрим всё более подробно, а также рассмотрим проблемные примеры из прошлых уроков.

Для полного понимания темы, необходимо знать двоичную систему счисления. На мой взгляд, будет сложно объяснить двоичную систему счисления новичку картоделу. Но скорее, не потому, что это какая-то сложная тема, а потому, что эти знания ему больше не пригодятся и лишь запутают его. Поэтому я не буду объяснять всё до мелочей, если сильно захотите, то сами найдете в интернете видео\статью о двоичной системе счисления и устройстве чисел с плавающей точкой.

Разница между числовыми типами

Вы уже знаете о некоторых различиях между real и integer, но я повторю их.
Integer – это любое целое число (-5, 0, 6).

Real – это число с плавающей точкой. Таким числом может быть как целое число, так и конечное дробное (-5, -2.554, 0, 1, 5.5).

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

Раньше я не акцентировал внимание на том, что значения типа real и значения типа integer это хоть и числа, но это разные типы данных. Компьютер хранит и вычисляет их по-разному, для него это вообще две разные вещи. А если они где-то используются вместе, например, в выражении, то в итоге все значения будут преобразованы к одному типу.

Посмотрите на такой код:
Скопировать в буфер

function Test takes nothing returns nothing local integer i = 2 local real r = 2.5 local integer a = r local real b = i endfunction

Такой код не компилируется потому, что мы пытаемся присвоить значение типа real переменной «a» с типом integer. Надеюсь, вы помните, как преобразовывать в друг друга типы real и integer с помощью функций R2I и I2R. Исправим ситуацию, добавим преобразование типов:

Скопировать в буфер

function Test takes nothing returns nothing local integer i = 2 local real r = 2.5 local integer a = R2I(r) local real b = i endfunction

Теперь код компилируется и работает, хоть он ничего полезного и не делает. Как вы заметили, я преобразовал только значение с типом real перед тем, как положить его в переменную «a» с типом integer, но ничего не сделал со значением типа integer перед тем, как положить его в переменную «b» с типом real. Это не значит, что там нет преобразования, просто преобразование integer в real происходит автоматически и использовать функцию I2R не всегда нужно.

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

function Test takes nothing returns nothing local integer i = 2 local real r = 2.5 local integer a = R2I(r) local real b = i call BJDebugMsg("a = " + I2S(a)) call BJDebugMsg("b = " + R2S(b)) endfunction

Вывод на экран:
Скопировать в буфер

a = 2 b = 2.000

Если преобразовать integer в real, то значение не изменится. А если преобразовать real в integer, то мы видим, что дробная часть исчезла. Обратите внимание на то, что при преобразовании real в integer, дробная часть именно исчезает, а не округляется. Например, если преобразовать в integer значение 2.88888 то в результате всё равно будет 2.

При преобразовании integer в real значение гарантировано не изменится, поэтому компьютер может не беспокоиться о последствиях и преобразовать тип автоматически. В случае преобразования real в integer значение может измениться (потерять дробную часть) поэтому используя функцию R2I, вы как будто даёте своё согласие на «преобразование с потерями».

Также необходимо знать о том, что арифметические операции ведут себя немного по-разному в зависимости от типов значений, над которыми они проводятся. Если оба значения имеют тип integer, то в результате получится число с типом integer и оно потеряет дробную часть. А если хотя бы одно значение имеет тип real, то в результате получится число с типом real и если у него есть дробная часть, то она останется.

Возьмем пример из прошлого урока:
Скопировать в буфер

function Test takes nothing returns nothing local integer a = 2 * 2 / 3 local integer b = 2 / 3 * 2 call BJDebugMsg("a = " + I2S(a)) call BJDebugMsg("b = " + I2S(b)) endfunction

Вывод на экран:
Скопировать в буфер

a = 1 b = 0

С точки зрения математики, обе переменные должны быть равны 1.3333(3). Если учитывать то, что это целые числа, то обе переменные должны быть равны 1. Но в этом примере, значение переменной «b» по какой-то причине равно нулю. Давайте посчитаем всё вручную, чтобы понять, что тут происходит. Начнем с выражения «a = 2 * 2 / 3»:

2. 4/3 = 1.333(3) но это тип integer поэтому откинем дробную часть и у нас получится 1.
По итогу значение переменной «а» равно 1, всё сходится. Теперь посчитаем выражение «b = 2 / 3 * 2»:
1. 2/3 = 0.666(6) но это тип integer поэтому откинем дробную часть и у нас получится 0.

Всё сошлось, значение переменной «b» равно 0. Дело в том, что у литералов также есть тип, а все литералы в примере выше имеют тип integer. Если заменить тип переменных на real, то ничего не поменяется:

Скопировать в буфер

function Test takes nothing returns nothing local real a = 2 * 2 / 3 local real b = 2 / 3 * 2 call BJDebugMsg("a = " + R2S(a)) call BJDebugMsg("b = " + R2S(b)) endfunction

Вывод на экран:
Скопировать в буфер

a = 1.000 b = 0.000

Чтобы числовой литерал имел тип real нужно, чтобы в числе была точка, например:
Скопировать в буфер

2.534 1.0 1. //писать ноль после точки необязательно, “1.” и “1.0” это одно и то же значение.

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

function Test takes nothing returns nothing local real a = 2. * 2. / 3. local real b = 2. / 3. * 2. call BJDebugMsg("a = " + R2S(a)) call BJDebugMsg("b = " + R2S(b)) endfunction

Вообще-то можно было поставить точку только в первом числе, а остальные преобразовались бы по цепочке. Тип real можно сравнить с зомби, он «заражает» значения с типом integer через операции. Потому, что, как я уже писал, если при выполнении арифметической операции хотя бы одно значение имеет тип real, то в результате получится число с типом real.

Теперь исправим пример с типом integer, чтобы обе переменные были равны 1:
Скопировать в буфер

function Test takes nothing returns nothing local integer a = 2 * 2 / 3 local integer b = R2I(2. / 3. * 2.) call BJDebugMsg("a = " + I2S(a)) call BJDebugMsg("b = " + I2S(b)) endfunction

В общем, не то чтобы это какое-то важное знание, но иногда нужно быть внимательным к таким деталям.

Точность

Уточню, под точностью имеются в виду не случайные колебания или ошибки, никаких случайностей и ошибок в вычислениях нет. Под точностью имеется в виду доступное для вычислений количество знаков. Например, в математике выражение 1/3 + 1/3 + 1/3 равно 1. Три трети, это одно целое. Но теперь представьте, что вы должны использовать только десятичные дроби при расчетах и к тому же вам доступно только три знака после точки. Тогда 1/3 будет равно 0.333, а всё выражение 0.333 + 0.333 + 0.333 = 0.999, а это уже не единица. В джассе всё немного иначе, но смысл примерно тот же.

Подробно рассматривать тип integer мы не будем, у него всё очень точно, только у него нет дробной части. Лучше сосредоточимся на типе real и разберемся, почему его зовут числом с плавающей точкой.

Для начала узнаем, как устроен тип real. Компьютер не может хранить и вычислять бесконечные числа, все числа имеют ограниченное количество знаков. В нашем случае и integer, и real состоят из 32 битов. Я не хочу всё усложнять и рассказывать вам о том, что такое двоичная система счисления. Если хотите, ищите статьи сами, но это знание не сильно поможет вам в создании карт. Поэтому лучше представьте, что у вас есть по 6 знаков на число. Число 6 взято для удобства и в нем нет никакого смысла, а 32 бита это тоже 32 знака, но только в двоичной системе счисления. Возьмем, например число 356, запишем его используя 6 знаков и получим 000356. Это было целое число, а что если нам нужно дробное число, например, 3.5? Мы можем использовать три знака для целой части и три знака для дробной, получится 003.500. А еще мы можем передвигать точку в зависимости от нужд, при этом изменяя доступное число знаков для дробной и целой части. Например: 4355.55, 0.06243, 324323., .000001. Ну, вы поняли, точка как-бы “плавает”, а такое число называют числом с плавающей точкой.

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

Прежде чем продолжить, познакомимся с такой нативной функцией:

native R2SW takes real r, integer width, integer precision returns string

где r – число, которое мы преобразовываем в строку,
width – минимальное количество знаков до точки (недостающие знаки будут пробелами),
precision – количество знаков после точки (недостающие знаки будут нулями)

Данная функция преобразовывает число типа real в строку (тип string). В отличие от похожей функции R2S, которая показывает только три знака после точки, функция R2SW принимает дополнительные аргументы и может показывать больше или меньше знаков после точки.

А теперь запустим такую функцию:
Скопировать в буфер

function TestReal takes nothing returns nothing local real a = 444444. + 0.22222222 local real b = 4444. + 0.22222222 local real c = 44. + 0.22222222 call BJDebugMsg(R2SW(a, 0, 8)) call BJDebugMsg(R2SW(b, 0, 8)) call BJDebugMsg(R2SW(c, 0, 8)) endfunction

Вывод на экран:
Скопировать в буфер

444444.21875000 4444.22216796 44.22222136

Если к первому числу добавить еще пару цифр к целой части, то дробная часть будет полностью вытеснена целой частью. А эти непонятно откуда взявшиеся числа, которые мы видим там, где должны быть двойки, это наша следующая проблема. Она связана как раз таки с двоичной системой счисления, я не смогу объяснить причину простыми словами, поэтому и не буду. Просто нужно привыкнуть к тому, что при любых операциях с типом real могут получиться мелкие ошибочки. А еще эти ошибки способны накапливается в переменных. Ничего страшного в этом нет, но стоит запомнить лишь одну вещь, нельзя строго сравнивать значения с типом real. Это значит, что не стоит использовать операции равно (==) и не равно (!=) имея дело с типом real. Потому, что из-за этих мелких колебаний значения типа real не всегда бывают одинаковыми, когда вы этого ожидаете. Лучше напишите такую функцию для сравнения значений с типом real:

Скопировать в буфер

function IsEqualReal takes real a, real b, real eps returns boolean if (a - b >= 0) then return a - b 

function B2S takes boolean b returns string if (b) then return "true" else return "false" endif endfunction function IsEqualReal takes real a, real b, real eps returns boolean if (a - b >= 0) then return a - b 

1.5 равно 2 при разнице 0.5 - true -0.5 равно 0.5 при разнице 1 - true 0.0005 равно 0 при разнице 0.01 - true -2 равно -4 при разнице 2 - true 1.5 не равно 2 при разнице 0.25 - false -0.5 не равно 0.5 при разнице 0.5 - false 0.0005 не равно 0 при разнице 0.0001 - false

а:=100; b:=60; a DIV b результат - 1 а MOD b результат - 40