Как в паскале найти степень от числа

Раздел: Стандартные функции Паскаля

Функция Power в Паскале (и многих других языках программирования) выполняет возведение числа в степень.

Синтаксис для вещественных чисел:


function Power(Base: Double; Expon: Double) : Double;

Синтаксис для целых чисел:


function Power(Base: LongInt; Expon: LongInt) : LongInt;

Эта функция возводит число Base в степень Expon и возвращает результат. В реальности функция возвращает результат выражения:


Exp(Expon * Ln(Base))

Пример использования функции Power

Пример приведён ниже:

program funcpower;

uses Math;        

var x, y, z : single;

begin
  x := 2;
  y := 3;
  z := Power(x, y);   //Z = X в степени Y
  WriteLn(z:0:2);  

  ReadLn;
end.

Здесь мы число 2 (переменная Х) возводим в степень 3 (переменная Y), то есть вычисляем следующую формулу:


Z = XY

Обратите внимание на подключенный модуль MATH.

Эта статья входит в раздел о подпрограммах модуля SYSTEM. И по идее описания функции Power здесь не должно быть. Но, так как в документации сказано, что функция Power объявлена в модуле SYSTEM, я решил включить данную статью именно в этот раздел (я же не виноват, что в документации косяк))).

Возведение в степень в Паскале

Возведение в степень в Паскале можно выполнить и без какой-то специальной функции,
используя функцию вычисления натурального логарифма
и функцию вычисления экспоненты.
О том, как это сделать, я рассказал здесь.

Однако, если есть специальная функция для возведения числа в степень, то почему бы ей и не воспользоваться? С одной стороны. С другой стороны — эта функция совершенно неожиданно требует подключения модуля MATH.

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


Exp(Expon * Ln(Base))

Однако, если мы будем делать именно так, эта формула будет неправильно работать с
отрицательными числами, потому что в документации сказано, что функция Ln работает только с положительными числами.

Так что функция Power в реальности несколько сложнее, чем приведённая выше формула.

Поэтому для разминки мы напишем свой аналог функции Power, который будет работать правильно. Но для начала вспомним как вычисляется степень числа:

Также напомню, что любое число в нулевой степени равно 1, а ноль в любой степени равен 0 (кроме нуля в нулевой — ноль в нулевой степени не определён, но мы будем возвращать в таких случаях ноль, хотя функция Power возвращает 1).

А теперь наш аналог функции Power:

function AVPower(Base: Double; Expon: Double) : Double;
var m     : byte;
    i     : integer;
    Res   : Double;
begin
  m := 0;
  if Expon < 0 then m := 1              //Отрицательная степень
  else if Expon = 0 then m := 2         //Нулевая степень
       else m := 3;                     //Положительная степень
  if Base < 0 then m := 10 + m          //Отрицательное число
  else if Base = 0 then m := 20 + m     //Число равно 0
       else m := 30 + m;                //Положительное число
  case m of
  11  :   //Отрицательное число, отрицательная степень
    begin //Если Expon - не целое число, то получаются комплексные числа
      Res := 1 / Exp(Abs(Expon) * Ln(Abs(Base)));
      i := Round(Expon);
      if Odd(i) then Res := -1 * Res;
    end;
  12, 32  :   //Нулевая степень
    Res := 1;
  13  :   //Отрицательное число, положительная степень
    begin //Если Expon - не целое число, то получаются комплексные числа
      Res := Exp(Expon * Ln(Abs(Base)));
      i := Round(Expon);
      if Odd(i) then Res := -1 * Res;
    end;
  21..23  :   //Число равно нулю
    Res := 0;
  31  :       //Положительное число, отрицательная степень
    Res := 1 / Exp(Abs(Expon) * Ln(Base));
  33  :       //Положительное число, положительная степень
    Res := Exp(Expon * Ln(Base));
  end;     

  AVPower := Res;
end;

Я сознательно немного всё усложнил, чтобы вас запутать )))

Пример использования функций Power и её аналога в программе:

x := 2;
y := 3;
z := Power(x, y);     //Z = X в степени Y
WriteLn(z:0:2); 

z := AVPower(x, y);   //Z = X в степени Y
WriteLn(z:0:2);

Здесь есть один подвох — если вы попытаетесь возвести отрицательное число в не целую степень, например, так:

-2^3,5

то стандартная функция Power вызовет ошибку во время выполнения программы. В своём аналоге я этого избежал, но надо понимать, что результат в этом случае будет неправильным (хотя с моей точки зрения это всё-равно лучше, чем аварийное завершение программы).

Это происходит потому, что при таком раскладе результатом являются комплексные числа, а операции с комплексными числами выполняются по другим правилам.

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

Ещё в моей функции используется функция Odd, о которой я ещё не рассказывал. Вкратце скажу, что она определяет, является ли число чётным. Более подробно о ней расскажу в отдельной статье.

Мы уже знаем, какие существуют функции для целых переменных. Это – нахождение модуля числа (Функция Abc), а также возведение числа в квадрат (Функция Sqr). В этом уроке мы рассмотрим функции, применяемые к дробным числам. Это функции Sqr — квадрат числа, Abs — модуль числа, Sqrt — корень числа, а также известные всем математические функции Sin, Cos, Arctan, Ln, Exp, Pi.

Program number12;
uses crt;
var A, B:real;
begin
clrscr;
A:=2.0;
B:=Sqr(A);
writeln('Sqr(2.0)=',B:4:2);
B:=Abs(-A);
writeln('Abs(-2.0)=',B:4:2);
B:=Sqrt(A);
writeln ('Sqrt(2)=',B:4:2);
B:=Sin(A);
writeln('Sin(2)=',B:6:3);
B:=Cos(A);
writeln('Cos(2)=',B:6:3);
B:=Arctan(A);
writeln('Arctan(2)=',B:6:3);
B:=Ln(A);
writeln('Ln(2)=',B:10:9);
B:=Exp (A);
writeln('Exp (2)=',B:10:9);
B:=Pi;
writeln('Pi=',B:10:9);
readln
end.

В строке №7 записывается функция Sqr. Это функция возведения числа в квадрат.

В строке №9 записывается операция нахождения модуля числа.
Функции Sqr и Abs мы разбирали в уроке Abs, Sqr в Pascal.

В строке №11 записывается функция Sqrt. Данная функция подсчитывает корень числа, стоящего в скобках после слова Sqrt. В нашем случае функция Sqrt будет считать корень из числа «2».

В строке №13 записываем функцию Sin. Данная функция будет подсчитывать синус числа, стоящего в скобках после записи функции.

Строка №15. Функция Cos подсчитывает косинус числа, стоящего в скобках после функции.

Строка №17. Функция Arctan вычисляет арктангенс числа, стоящего в скобках после записи функции.

Строка №19. Функция Ln подсчитывает логарифм числа, стоящего в скобках после записи функции.

Строка №21. Функция Exp возводит число «e» (экспонента — 2.72…) в степень, значение которой указывается в скобках после слова Exp. Т.е. в нашем случае число «e» будет возведено в степень «2».

Строка №23. Переменной «B» будет присвоено значение числа «?».

Дополнение к материалу.

• Функции Sqrt, Sin, Cos, Arctan, Ln, Exp, Pi определены только для вещественных (дробных) чисел.
• В Паскале не существует операции возведения в степень. Есть только операция возведения числа в квадрат (Sqr). Чтобы возвести число в степень используют операцию умножения. Например, чтобы возвести число 3 в 5-ю степень необходимо записать 3*3*3*3*3

Возведение в степень

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

{Пример
демонстрирует возведение числа Xв степеньN}

programStepen;

var

X,
Res: Real;

N,
I: Integer;

begin

{***
Ввод данных ***}

Write(‘Введите
значения X и N:’);

Readln(X,
N);

{***
Возведение в степень ***}

Res:= 1; {Присваиваем начальное значение
переменнойRes}

forI:= 1toNdo {Цикл возведения в степень}

Res
:= Res * X;

{***
Вывод результата на экран ***}

Writeln(‘X^N=’,
Res:5:2);

end.

Цикл возведения
в степень целесообразно применять, если
значение степени заранее неизвестно.

Если требуется
возвести число в квадрат или в куб, то
проще поступить следующим образом: Y
:= X * XилиY := X
* X * X.

Для возведения
числа «–1» в целую, положительную степень
рекомендуется следующий код:

ifOdd(N)then
{Если число нечетное… }

Y
:= –1

else{Иначе (если число четное)… }

Y:= 1;

Odd– это функция, возвращающая логический
результатTrue, если
аргумент является нечетным числом,
иначе возвращаетFalse.

3.6. Тип данных «массив» – объявление и использование

Массив —
упорядоченный набор данных для хранения
множества элементов одного типа,
идентифицируемых с помощью одного или
нескольких индексов. Количество
используемых индексов массива может
быть различным. Массивы с одним индексом
называют одномерными, с двумя — двумерными
и т.д. Одномерный массив соответствует
вектору в математике, двумерный —
матрице. Массивы с числом измерений >
2встречаются редко.

Формат объявления
переменных типа «массив» представлен
ниже:

var

<список
переменных> = array[<индексы>]of<тип данных>;

где <список
переменных>– наименование одной
или нескольких переменных (через
запятую);

<индексы>– описание диапазона индексов для
каждого измерения массива, например:

— [1..10] –
соответствует одномерному массиву
(вектору), первый элемент которого имеет
индекс «1», а последний «10» (всего 10
элементов);

— [0..4] – соответствует
одномерному массиву, первый элемент
которого имеет индекс «0», а последний
«4» (всего 5 элементов);

— [1..5, 1..4] –
соответствует двухмерному массиву
(матрице), состоящему из 5 строк (индексация
от 1 до 5) и 4 столбцов (индексация от 1 до
4);

<тип данных>– любой тип данных, известный компиляторуPascal, например,Integer,Byte,Real,Boolean,Char,string, а также типы данных,
объявленные программистом.

Ниже приведены
примеры объявления переменных типа
«массив»:

{2
вектора из 10 элементов типа Integer.
Индексация начинается с «1»}

Vect1,
Vect2: array[1..10]
of
Integer;

{Матрица
вещественных чисел 8 х 6. Индексация
начинается с «0»}

Matr:array[0..7, 0..5]ofReal;

{Список
из 20 строк.
Индексация начинается с «1»}

StrList:
array[1..20]
of string;

Во многих случаях
более удобным является однократное
объявление типа данных «массив» в начале
программы (в секции type).
Объявленный таким способом тип данных
в дальнейшем можно использовать при
описании переменных. Данный способ
имеет следующие преимущества:

— при необходимости
внесения изменений в объявление массива
достаточно это сделать в одном месте;

— переменные,
объявленные в секции varс использованием отдельного типа,
являются совместимыми, т.е. между ними
допускается операция присвоения «:=»;

— при использовании
в программе процедур и функций у
программиста появляется возможность
объявления параметров процедуры, имеющих
тип «массив».

Ниже представлен
пример объявления нового типа данных
«массив», а также переменных этого типа:

type

{Объявление
нового типа данных «матрица»}

TMatrix=array[1..10, 1..20]ofReal;

var

{Объявление
переменных типа
TMatrix}

Matrix1,
Matrix2, Matrix3: TMatrix;

…………………………………

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

{Установка
нового значения 3-го элемента вектора}

Vect[3]
:= 3.45;{Установка заданного числового
значения}

Vect[3]
:=Random;{Установка
случайного значения}

Readln(Vect[3]);{Значение вводится пользователем с
клавиатуры}

{Чтение
2-го элемента вектора}

Value:=Vect[2];{Присвоение в
переменную Value}

Writeln(Vect[2]);{Вывод на экран}

{Вычисление
суммы первых трех элементов}

Summa:=Vect[1] +Vect[2]
+Vect[3];

Ниже приведены
примеры чтения и записи элементов
двухмерного массива (матрицы):

{Установка
заданного значения элемента матрицы с
координатами 4, 3}

{индекс
4 – это номер строки матрицы, 3 – номер
столбца матрицы}

Matrix[4,
3] := 123.456;

Readln(Matrix[2,
4]);{Ввод элемента (2, 4) с клавиатуры}

Writeln(Matrix[I,J]);{Вывод элемента (I, J)
на экран}

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

for
I := 1 to
10 do
{цикл
по I от
1 до 10}

Vect[I]
:=Random;{I-му элементу
присваивается случайное число}

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

programFindMaxElement;

const
{Объявление
констант}

Rows
= 5; {Число строк матрицы}

Cols
= 4; {Число столбцов матрицы}

var

{Объявление
массива размером Rows x Cols}

Mas:
array[1..Rows,
1..Cols] of
Real;

I,
J: Integer; {Объявление переменных цикла}

MaxValue:
Real; {Максимальное значение}

MaxRowIndex:
Integer; {Номер строки максимального
значения}

MaxColIndex:
Integer; {Номер столбца максимального
значения}

begin

{Цикл
заполнения массива и вывода элементов
на экран}

forI := 1toRowsdo{Цикл по I (перебор
строк матрицы)}

begin{можно было обойтись и без этого
begin..end }

forJ := 1toColsdo{Цикл по J (перебор
столбцов матрицы)}

begin{а этот begin..end требуется обязательно}

{Присваиваем
элементу (I, J) случайное значение}

Mas[I,
J] := Random;

{Печатаем
значение элемента (все — на одной строке)}

Write(Mas[I,
J]:8:2, ‘ ‘);

ifJ = Colsthen{Если это последний столбец,
}

Writeln;
{то осуществляем перевод строки}

end;

end;{Данный begin..end здесь — для улучшения
читабельности кода}

{Перед
началом поиска максимального значения
переменная

MaxValue
уже должна иметь любое значение, но это
значение

не
должно быть больше, чем элементы матрицы.
Поэтому

достаточно
взять в качестве первоначального
значения

любой
элемент матрицы Mas, например самый
первый}

MaxValue
:= Mas[1, 1]; {Запоминаем первый элемент}

MaxRowIndex
:= 1; {Запоминаем номер строки 1-го элемента}

MaxColIndex
:= 1; {Запоминаем номер столбца 1-го
элемента}

{Цикл
поиска максимального элемента}

forI := 1toRowsdo{Цикл по I (перебор
строк матрицы)}

forJ := 1toColsdo{Цикл по J (перебор
столбцов матрицы)}

begin

{Если
текущий элемент (I, J) больше, чем MaxValue,

то
записываем этот элемент в MaxValue и сохраняем
его координаты}

if
Mas[I, J] > MaxValue then

begin

MaxValue
:= Mas[I, J];

MaxRowIndex
:= I;

MaxColIndex
:= J;

end;

end;

{Выводим
найденные значения на экран}

Writeln(‘Max
value=’, MaxValue:8:2, ‘;
Row=’,

MaxRowIndex,
‘; Col=’,
MaxColIndex);

Readln;

end.

Данный
пример весьма прост и снабжен подробными
комментариями. Очень важно детально
разобраться с данным примером, поскольку
от этого зависит успешность выполнения
задания из варианта (п. 3.8).

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #