Math в Delphi

Math в Delphi

В этом уроке мы рассмотрим работу с математическими операциями в Delphi, изучим множество различных полезных процедур и функций.
При выполнении математических действий, математические операции производятся последовательно, но с учетом того, что сперва выполняется умножение, деление и операции, заключенные внутри скобок, т.е. соблюдаются основные арифметические законы. Рассмотрим простейший пример:
[cc lang=»delphi»]a := 2+2*2;
b := (2+2)*2[/cc]
В результате выполнения вышеприведенной строки кода, переменная a будет равна 6, а не 8; переменная b же будет равна 8.
Таким образом все математические операции выполняются исходя из иерархии (структуры) самих математических операций.
Внутри математических операций возможно использование любых функций, если они возвращают численное значение, а также возможно использование и стандартных функций, таких как sin, cos и т.п., которые уже предусмотрены в Delphi.
[cc lang=»delphi»]a := sin(b)*2+1;[/cc]
Допустима неограниченная вложенность различных функций, операций, скобок и т.п.:
[cc lang=»delphi»]a := sin(cos(b/2+sqr(c))) * 2 + MyFunc(d);[/cc]
Теперь, давайте рассмотрим самые необходимые и часто используемые функции, работающие с числами, которые уже предусмотрены в Delphi.

Название функции Описание функции
Abs Возвращает абсолютное значение аргумента (модуль)
Sin Возвращает синус аргумента. Аргумент необходимо указывать в радианах
Cos Возвращает косинус аргумента. Аргумент необходимо указывать в радианах
Exp Экспонента (e в степени аргумента)
Ln Возвращает натуральный логарифм аргумента
Sqr Возвращает квадрат аргумента
Sqrt Возвращает квадратный корень аргумента
Int Возвращает целую часть нецелочисленного аргумента
Frac Возвращает дробную часть нецелочисленного числа
Round Округление аргумента до ближайшего целого числа
Trunc Возвращает целую часть вещественного числа

здравствуйте а как найти десятичный логарифм числа

Добавьте в раздел uses в список модулей модуль Math. После этого вы можете пользоваться функцией Log10(x), которая позволяет найти десятичный логарифм от x. Также будут доступны функции Log2(X) — логарифм от x по основанию 2 и LogN (N,X) — логарифм от x по основанию n.

извините у меня еще один вопрос, а как в степень возводить ?

Функции Delphi модуля Math

Модуль Math

Предлагаем список функций модуля Math, используемого в среде разработки Delphi.

ArcCos Арккосинус числа, возвращается в радианах
ArcSin Арксинус числа, возвращается в радианах
DegToRad Преобразование значения градусов в радианы
IsInfinite Проверяет, является ли число с плавающей запятой бесконечным
IsNaN Выясняет, содержит ли число с плавающей запятой настоящее число
Log10 Вычисляет логарифм числа с основанием 10
Max Выдает максимальное число из двух целых значений
Mean Выдает среднее число из набора чисел
Min Выдает минимальное из двух целых значений
RadToDeg Преобразовывает значение радиана в градусы
RandomRange Генерирует произвольное число в пределах введённого диапазона
Sum Находит сумму элементов массива, состоящего из чисел с плавающей точкой
Tan Тангенс числа

Math — математика, статистика, финансы. Краткий справочник по функциям в Delphi

Тригонгометрические функции:

function ArcCos(X: Extended): Extended;
function ArcSin(X: Extended): Extended;
function ArcTan2(Y, X: Extended): Extended; Арктангенс X/Y возвращает угол в квадранте
procedure SinCos(Theta: Extended; var Sin, Cos: Extended) register; возвращает сразу и синус и косинус, вычисления в 2 раза быстрее чем Sin, Cos по отдельности
function Tan(X: Extended): Extended;
function Cotan(X: Extended): Extended;
function Hypot(X, Y: Extended): Extended; Возвращает значение гипотенузы по катетам

Конвертация углов

function DegToRad(Degrees: Extended): Extended;
function RadToDeg(Radians: Extended): Extended;
function GradToRad(Grads: Extended): Extended;
function RadToGrad(Radians: Extended): Extended;
function CycleToRad(Cycles: Extended): Extended;
function RadToCycle(Radians: Extended): Extended;

function Cosh(X: Extended): Extended;
function Sinh(X: Extended): Extended;
function Tanh(X: Extended): Extended;
function ArcCosh(X: Extended): Extended;
function ArcSinh(X: Extended): Extended;
function ArcTanh(X: Extended): Extended;

Логарифмы, экспоненты и возведение в степень

function LnXP1(X: Extended): Extended; — натуральный логариф x+1 (для более высокой точности при x близких к нулю)
function Log10(X: Extended): Extended; — десятичный логарифм
function Log2(X: Extended): Extended; — логарифм по основанию 2
function LogN(Base, X: Extended): Extended; — логарифм по произвольному основанию
function IntPower(Base: Extended; Exponent: Integer): Extended register;
function Power(Base, Exponent: Extended): Extended;

procedure Frexp(X: Extended; var Mantissa: Extended; var Exponent: Integer) register; — возвращает мантису и экспоненту
function Ldexp(X: Extended; P: Integer): Extended register; — возвращает X*2**P
function Ceil(X: Extended):Integer; — округляет до ближайшего большего целого
function Floor(X: Extended): Integer; — округляет до ближайшего меньшего целого
function Poly(X: Extended; const Coefficients: array of Double): Extended; вычисление полинома

Статистические функции

function Mean(const Data: array of Double): Extended; среднее арифметическое
function Sum(const Data: array of Double): Extended register; сумма ряда
function SumInt(const Data: array of Integer): Integer register; сумма ряда целых чисел
function SumOfSquares(const Data: array of Double): Extended; сумма квадратов
procedure SumsAndSquares(const Data: array of Double; var Sum, SumOfSquares: Extended) register; сумма и сумма квадратов одной функцией
function MinValue(const Data: array of Double): Double; минимальное значение в ряду
function MinIntValue(const Data: array of Integer): Integer; минимальное значение в ряду целых
function Min(A,B) минимальное значение из 2х чисел (overload функции для Integer, Int64, Single, Double, Extended)
function MaxValue(const Data: array of Double): Double;
function MaxIntValue(const Data: array of Integer): Integer;
function Max(A,B);
function StdDev(const Data: array of Double): Extended; стандартное отклонение
procedure MeanAndStdDev(const Data: array of Double; var Mean, StdDev: Extended); — среднее арифметическое и стандартное отклонение
function PopnStdDev(const Data: array of Double): Extended; распределение стандартного отклонения (Population Standard Deviation)
function Variance(const Data: array of Double): Extended;
function PopnVariance(const Data: array of Double): Extended; (Population Variance)
function TotalVariance(const Data: array of Double): Extended;
function Norm(const Data: array of Double): Extended; среднее квадратичное (Sqrt(SumOfSquares))
procedure MomentSkewKurtosis(const Data: array of Double;
var M1, M2, M3, M4, Skew, Kurtosis: Extended); основные статистические моменты
function RandG(Mean, StdDev: Extended): Extended; — случайные числа с Гауссовским распределением

function DoubleDecliningBalance(Cost, Salvage: Extended; Life, Period: Integer): Extended;
function FutureValue(Rate: Extended; NPeriods: Integer; Payment, PresentValue: Extended; PaymentTime: TPaymentTime): Extended;
function InterestPayment(Rate: Extended; Period, NPeriods: Integer; PresentValue,
FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function InterestRate(NPeriods: Integer;
Payment, PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function InternalRateOfReturn(Guess: Extended;
const CashFlows: array of Double): Extended;
function NumberOfPeriods(Rate, Payment, PresentValue, FutureValue: Extended;
PaymentTime: TPaymentTime): Extended;
function NetPresentValue(Rate: Extended; const CashFlows: array of Double;
PaymentTime: TPaymentTime): Extended;
function Payment(Rate: Extended; NPeriods: Integer;
PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function PeriodPayment(Rate: Extended; Period, NPeriods: Integer;
PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function PresentValue(Rate: Extended; NPeriods: Integer;
Payment, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function SLNDepreciation(Cost, Salvage: Extended; Life: Integer): Extended;
function SYDDepreciation(Cost, Salvage: Extended; Life, Period: Integer): Extended;

Математические операции Delphi

Для дальнейшего изучения языка Delphi рассмотрим математические операции. Они делятся на арифметические, логические операции и операции отношения.

Арифметические операции выполняют арифметические действия в выражениях над значениями переменных.

Таблица 5. Арифметические операции

Операция Действия Типы операндов Тип результата
+ Сложение Целый/вещественный Целый/вещественный
Вычитание Целый/вещественный Целый/вещественный
* Умножение Целый/вещественный Целый/вещественный
/ Деление Целый/вещественный Вещественный
Div Деление нацело Целый Целый
Mod Остаток от деления Целый Целый

Особое внимание следует обратить на то, что тип результата деления – всегда вещественное число.

Оператор DIV позволяет получить целую часть результата деления одного числа на другое. Например, значение выражения 5 DIV 2 равно 2.

Оператор MOD (деление по модулю) позволяет получить остаток от деления одного числа на другое. Например, значение выражения 15 MOD 7 равно 1.

При вычислении значений выражений, как и в математике, учитывается порядок действий. Сначала выполняются операторы *, /, DIV, MOD, а затем – операторы + и -. Для задания нужного порядка выполнения операций можно использовать скобки.

Операции отношениясравнивают два операнда и определяют истинность или ложность выражения. Результат операции отношения имеет тип Boolean, который принимает два значения: True (истина) и False (ложь).

Таблица 6. Операции отношения

Таблица 7. Логические операции

Операция Название Выражение Результат
= Равно А=В True, если А равно В
<> Не равно A<>B True, если А не равно В
> Больше A>B True, если А больше В
= Больше или равно A>=B True, если А больше или равно В
Операция Действие Пример выражения
Not Логическое отрицание Not A
And Логическое и A and B
Or Логическое или A or B
Xor Исключающее или A xor B

Стандартные математические функции Delphi

В языке Delphi имеются следующие математические функции:

Таблица 8. Математические функции

Функция Значение
Abs (x) Возвращает абсолютное значение (модуль) числа х
Sqrt (x) Возвращает число, равное квадратному корню из х
Sqr (x) Возвращает число, равное квадрату числа х
Sin (x) Возвращает синус числа х, где х – угол в радианах
Cos (x) Возвращает косинус числа х, где х – угол в радианах
Arctan (x) Возвращает арктангенс числа х, где х – угол в радианах
Exp (x) Возвращает число, равное е в степени х
Ln (x) Возвращает число, равное натуральному логарифму от числа х
Pi Число Пи
Random (x) Возвращает случайное число от 0 до х-1. При использовании функции без параметров генерируются случайные числа от 0 до 1.
Trunc (x) Возвращает число, равное целой части х (при округлении отбрасывается дробная часть). Усеченное число имеет тип LongInt.
Frac (x) Возвращает число, равное дробной части числа х. Например, Frac(2.4) возвращает 0.4, Frac (3.99) возвращает 0.99.
Int (x) Возвращает число, равное целой части числа х. Например, Int (2.4) возвращает 2.0, Int (0.99) возвращает 0.0.
Round (x) Возвращает число, равное целой части числа х (округление происходит по правилам математики, т.е. к ближайшему целому). Процедура является универсальной, так как результат может быть как целым, так и вещественным числом.
Ord (x) Определяет четность числа. Возвращает значение True, если число х нечетно.

Линейная алгоритмическая структура.

Последнее изменение этой страницы: 2020-01-25; Нарушение авторского права страницы

Math в Delphi

Maths Routines In Delphi

  • const< Ranges of the IEEE floating point types, including denormals >
    MinSingle = 1.5e-45;
    MaxSingle = 3.4e+38;
    MinDouble = 5.0e-324;
    MaxDouble = 1.7e+308;
    MinExtended = 3.4e-4932;
    MaxExtended = 1.1e+4932;
    MinComp = -9.223372036854775807e+18;
    MaxComp = 9.223372036854775807e+18;
  • All angle parameters and results of trig functions are in radians.

Most of the following trig and log routines map directly to Intel 80387 FPU
floating point machine instructions. Input domains, output ranges, and
error handling are determined largely by the FPU hardware.
Routines coded in assembler favor the Pentium FPU pipeline architecture.
———————————————————————

Trigonometric functions
function ArcCos(X: Extended): Extended; < IN: |X| 0 OUT: [-PI..PI] radians >
function ArcTan2(Y, X: Extended): Extended;

< IntPower: Raise base to an integral power. Fast. >
function IntPower(Base: Extended; Exponent: Integer): Extended register;

< Power: Raise base to any power.
For fractional exponents, or |exponents| > MaxInt, base must be > 0. >
function Power(Base, Exponent: Extended): Extended;

< Frexp: Separates the mantissa and exponent of X. >
procedure Frexp(X: Extended; var Mantissa: Extended; var Exponent: Integer) register;

< Ldexp: returns X*2**P >
function Ldexp(X: Extended; P: Integer): Extended register;

Common commercial spreadsheet macro names for these statistical and
financial functions are given in the comments preceding each function.
———————————————————————

< Sum: Sum of values. (SUM) >
function Sum(const Data: array of Double): Extended register;
function SumInt(const Data: array of Integer): Integer register;
function SumOfSquares(const Data: array of Double): Extended;
procedure SumsAndSquares(const Data: array of Double;
var Sum, SumOfSquares: Extended) register;

< MinValue: Returns the smallest signed value in the data array (MIN) >
function MinValue(const Data: array of Double): Double;
function MinIntValue(const Data: array of Integer): Integer;

function Min(A,B: Integer): Integer; overload;
function Min(A,B: Int64): Int64; overload;
function Min(A,B: Single): Single; overload;
function Min(A,B: Double): Double; overload;
function Min(A,B: Extended): Extended; overload;

< MaxValue: Returns the largest signed value in the data array (MAX) >
function MaxValue(const Data: array of Double): Double;
function MaxIntValue(const Data: array of Integer): Integer;

function Max(A,B: Integer): Integer; overload;
function Max(A,B: Int64): Int64; overload;
function Max(A,B: Single): Single; overload;
function Max(A,B: Double): Double; overload;
function Max(A,B: Extended): Extended; overload;

< MeanAndStdDev calculates Mean and StdDev in one call. >
procedure MeanAndStdDev(const Data: array of Double; var Mean, StdDev: Extended);

< Population Standard Deviation (STDP): Sqrt(PopnVariance).
Used in some business and financial calculations. >
function PopnStdDev(const Data: array of Double): Extended;

< Total Variance: SUM(i=1,N)[(X(i) - Mean)**2] >
function TotalVariance(const Data: array of Double): Extended;

< MomentSkewKurtosis: Calculates the core factors of statistical analysis:
the first four moments plus the coefficients of skewness and kurtosis.
M1 is the Mean. M2 is the Variance.
Skew reflects symmetry of distribution: M3 / (M2**(3/2))
Kurtosis reflects flatness of distribution: M4 / Sqr(M2) >
procedure MomentSkewKurtosis(const Data: array of Double;
var M1, M2, M3, M4, Skew, Kurtosis: Extended);

< RandG produces random numbers with Gaussian distribution about the mean.
Useful for simulating data with sampling errors. >
function RandG(Mean, StdDev: Extended): Extended;

From the point of view of A, amounts received by A are positive and
amounts disbursed by A are negative (e.g. a borrower’s loan repayments
are regarded by the borrower as negative).

Interest rates are per payment period. 11% annual percentage rate on a
loan with 12 payments per year would be (11 / 100) / 12 = 0.00916667

type
TPaymentTime = (ptEndOfPeriod, ptStartOfPeriod);

< Double Declining Balance (DDB) >
function DoubleDecliningBalance(Cost, Salvage: Extended;
Life, Period: Integer): Extended;

< Future Value (FVAL) >
function FutureValue(Rate: Extended; NPeriods: Integer; Payment, PresentValue:
Extended; PaymentTime: TPaymentTime): Extended;

< Interest Payment (IPAYMT) >
function InterestPayment(Rate: Extended; Period, NPeriods: Integer; PresentValue,
FutureValue: Extended; PaymentTime: TPaymentTime): Extended;

< Interest Rate (IRATE) >
function InterestRate(NPeriods: Integer;
Payment, PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;

< Internal Rate of Return. (IRR) Needs array of cash flows. >
function InternalRateOfReturn(Guess: Extended;
const CashFlows: array of Double): Extended;

< Number of Periods (NPER) >
function NumberOfPeriods(Rate, Payment, PresentValue, FutureValue: Extended;
PaymentTime: TPaymentTime): Extended;

< Net Present Value. (NPV) Needs array of cash flows. >
function NetPresentValue(Rate: Extended; const CashFlows: array of Double;
PaymentTime: TPaymentTime): Extended;

< Payment (PAYMT) >
function Payment(Rate: Extended; NPeriods: Integer;
PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;

< Period Payment (PPAYMT) >
function PeriodPayment(Rate: Extended; Period, NPeriods: Integer;
PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;

< Present Value (PVAL) >
function PresentValue(Rate: Extended; NPeriods: Integer;
Payment, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;

< Straight Line depreciation (SLN) >
function SLNDepreciation(Cost, Salvage: Extended; Life: Integer): Extended;

< Sum-of-Years-Digits depreciation (SYD) >
function SYDDepreciation(Cost, Salvage: Extended; Life, Period: Integer): Extended;

<: returns the sum of square difference of
an Array of Extended Reals from a given Value >
function SumSqDiffEArray (const B: array of Extended; Diff: Extended): Extended;

<: returns the sum of pairwise product two
Arrays of Extended Reals >
function SumXYEArray (const X, Y: array of Extended): Extended;

<: returns npr i.e permutation of r objects from n.
Only values of N up to 1547 are handled returns 0 if larger
If R > N then 0 is returned >
function PermutationX (N, R: Cardinal): Extended;

<: returns ncr i.e combination of r objects from n.
These are also known as the Binomial Coefficients
Only values of N up to 1547 are handled returns 0 if larger
If R > N then 0 is returned >

function BinomialCoeff (N, R: Cardinal): Extended;

<: returns true if all elements of x>ESBTolerance >
function IsPositiveEArray (const X: array of Extended): Boolean;

<: returns the geometric mean of values>
function GeometricMean (const X: array of Extended): Extended;

<: returns the harmonic mean of values>
function HarmonicMean (const X: array of Extended): Extended;

<: returns the arithmetic mean of values>
function ESBMean (const X: array of Extended): Extended;

<: returns the variance of values, assuming a sample.
Square root this value to get Standard Deviation >
function SampleVariance (const X: array of Extended): Extended;

<: returns the variance of values, assuming a population.
Square root this value to get Standard Deviation >
function PopulationVariance (const X: array of Extended): Extended;

<: returns the mean and variance of values, assuming a sample.
Square root the Variance to get Standard Deviation >
procedure SampleVarianceAndMean (const X: array of Extended;
var Variance, Mean: Extended);

<: returns the mean and variance of values, assuming a population.
Square root the Variance to get Standard Deviation >
procedure PopulationVarianceAndMean (const X: array of Extended;
var Variance, Mean: Extended);

<: returns the median (2nd quartiles) of values. array
MUST be sorted before using this operation >
function GetMedian (const SortedX: array of Extended): Extended;

<: returns the mode (most frequent) of values. array
MUST be sorted before using this operation. Function is False
if no Mode exists >
function GetMode (const SortedX: array of Extended; var Mode: Extended): Boolean;

<: returns the 1st and 3rd quartiles - median is 2nd of values.
The array MUST be sorted before using this operation >
procedure GetQuartiles (const SortedX: array of Extended; var Q1, Q3: Extended);

Математические процедуры и функции в Delphi

Часто при написании проектов для того, чтобы сделать простейшую операцию мы прописываем десятки строк, не зная, что существуют стандартные функции, которые сделаны создателями Delphi, для того чтобы облегчить нам жизнь. Сегодня вашему вниманию предлагаю несколько функций:

1. Математические функции
2. Функции и процедуры для работы с символьным типом Char
3. Функции и процедуры для работы со строками PChar
4. Преобразования различных типов

Для работы с этими функциями требуется в раздел uses дописать модуль Math; Пример:

[code=delphi]
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Math;
[/code=delphi]

Название: DivMod
Описание:Выполняет целочисленное деление, учитывая остаток
Пример:
[code=delphi]DivMod(delimoe,delitel,chastnoe, ostatok);[/code=delphi]
Параметры:
— Delimoe – число типа integer
— Delitel – число типа Word
— Chastn – перменная типа Word, котрой будет присвоено значение частного
— Ostatok – переменная типа Word, которой будет присвоено значение остатка

Название: Abs
Описание:Возвращает абсолютное значение числа
Пример:
[code=delphi]otv:=Abs(i);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоено абсолютное значение числа i

Название: Round
Описание:Округляет число до ближайшего целого
Пример:
[code=delphi]Otv:=Round(i);[/code=delphi]
Параметры:
Otv – переменная числового типа, которой будет присвоено округленное до ближайшего значение числа i

Название: RoundTo
Описание:Округляет вещественное число до заданного количества разрядов или заданной степени
Пример:
[code=delphi]Otv:=RoundTo(i,n);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоено округленное до nколичества разрядов или заданной степени число i

Название: Ceil
Описание:Округляет число в большую сторону
Пример:
[code=delphi]Otv:=Ceil(i);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоено округленное в большую сторону значение числа i

Название: Floor
Описание:Округляет число в меньшую сторону
Пример:
[code=delphi]Otv:=Floor(i);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоено округленное в меньшую сторону значение числа i

Название: Frac
Описание:Возвращает дробную часть числа
Пример:
[code=delphi]Otv:=Frac(i);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоена дробная часть числа i

Название: Int
Описание:Возвращает целую часть числа
Пример:
[code=delphi]Otv:=Int(i);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоена целая часть числа i

Название: IntPower
Описание:Возведение числа в целую степень
Пример:
[code=delphi]Otv:=IntPower(i, st);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоено возведенное в степень st числo i
St – integer, степень
I – integer, число, которое нужно

Название: Ln
Описание:Вычисляет натуральный логариф
Пример:
[code=delphi]Otv:=Ln(i);[/code=delphi]
Параметры:
Otv – переменная вещественного типа, которой будет присвоен натуральный логарифм

Это далеко не все стандартные функции. Ждите продолжение в следующем номере Vr-online.

Математические операции Delphi

Для дальнейшего изучения языка Delphi рассмотрим математические операции. Они делятся на арифметические, логические операции и операции отношения.

Арифметические операции выполняют арифметические действия в выражениях над значениями переменных.

Таблица 5. Арифметические операции

Операция Действия Типы операндов Тип результата
+ Сложение Целый/вещественный Целый/вещественный
Вычитание Целый/вещественный Целый/вещественный
* Умножение Целый/вещественный Целый/вещественный
/ Деление Целый/вещественный Вещественный
Div Деление нацело Целый Целый
Mod Остаток от деления Целый Целый

Особое внимание следует обратить на то, что тип результата деления – всегда вещественное число.

Оператор DIV позволяет получить целую часть результата деления одного числа на другое. Например, значение выражения 5 DIV 2 равно 2.

Оператор MOD (деление по модулю) позволяет получить остаток от деления одного числа на другое. Например, значение выражения 15 MOD 7 равно 1.

При вычислении значений выражений, как и в математике, учитывается порядок действий. Сначала выполняются операторы *, /, DIV, MOD, а затем – операторы + и -. Для задания нужного порядка выполнения операций можно использовать скобки.

Операции отношениясравнивают два операнда и определяют истинность или ложность выражения. Результат операции отношения имеет тип Boolean, который принимает два значения: True (истина) и False (ложь).

Таблица 6. Операции отношения

Таблица 7. Логические операции

Операция Название Выражение Результат
= Равно А=В True, если А равно В
<> Не равно A<>B True, если А не равно В
> Больше A>B True, если А больше В
= Больше или равно A>=B True, если А больше или равно В
Операция Действие Пример выражения
Not Логическое отрицание Not A
And Логическое и A and B
Or Логическое или A or B
Xor Исключающее или A xor B

Стандартные математические функции Delphi

В языке Delphi имеются следующие математические функции:

Таблица 8. Математические функции

Функция Значение
Abs (x) Возвращает абсолютное значение (модуль) числа х
Sqrt (x) Возвращает число, равное квадратному корню из х
Sqr (x) Возвращает число, равное квадрату числа х
Sin (x) Возвращает синус числа х, где х – угол в радианах
Cos (x) Возвращает косинус числа х, где х – угол в радианах
Arctan (x) Возвращает арктангенс числа х, где х – угол в радианах
Exp (x) Возвращает число, равное е в степени х
Ln (x) Возвращает число, равное натуральному логарифму от числа х
Pi Число Пи
Random (x) Возвращает случайное число от 0 до х-1. При использовании функции без параметров генерируются случайные числа от 0 до 1.
Trunc (x) Возвращает число, равное целой части х (при округлении отбрасывается дробная часть). Усеченное число имеет тип LongInt.
Frac (x) Возвращает число, равное дробной части числа х. Например, Frac(2.4) возвращает 0.4, Frac (3.99) возвращает 0.99.
Int (x) Возвращает число, равное целой части числа х. Например, Int (2.4) возвращает 2.0, Int (0.99) возвращает 0.0.
Round (x) Возвращает число, равное целой части числа х (округление происходит по правилам математики, т.е. к ближайшему целому). Процедура является универсальной, так как результат может быть как целым, так и вещественным числом.
Ord (x) Определяет четность числа. Возвращает значение True, если число х нечетно.

Линейная алгоритмическая структура.

Последнее изменение этой страницы: 2020-01-25; Нарушение авторского права страницы

Pointer Math (Delphi)

Pointer math is simply treating any given typed pointer in some narrow instances as a scaled ordinal where you can perform simple arithmetic operations directly on the pointer variable. It also allows you to treat such a pointer variable as an unbounded array using the array [] operator. Notice in the example above that incrementing the index of an array of a type is equivalent to incrementing a pointer to that type. An increment of one bumps the pointer by the size an array element in bytes, not by one byte.

The POINTERMATH directive has a local scope. That is, if you turn this directive ON and do not turn it off in the module, it will remain on only until the end of the module. Also, if you declare a typed pointer with this directive ON, any variable of that type allows scaled pointer arithmetic and array indexing, even after the directive has been turned OFF Similarly, any block of code surrounded by this directive allows arithmetic operations for ANY typed pointers within the block regardless of whether the typed pointer was originally declared with POINTERMATH ON.

This directive affects only typed pointers. Variables of type Pointer do not allow the pointer math features, since type Pointer is effectively pointing to a void element, which is 0 bytes in size. Untyped var or const parameters are not affected because they are not really pointers.

Создание игр на Делфи

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

Цель данной статьи научить новичков производить расчеты в Delphi , переводить математические формулы в Delphi формулы, переводить формулы в код, написанный на паскале и все тому подобное.

Для того, чтобы пользоваться простыми формулами типа а+ b = c не нужно делать ничего сложного. Для начала в разделе var обьявляем все три необходимые переменные:

Тип integer означает, что используемые значения в переменных будут представлять из себя целые числа в диапазоне от -25 тысяч с лишним до +25 тысяч. Если же мы будем использовать дробные числа, то нужно обьвлять переменные типа real .

В нужном месте мы записываем следующий код:

Эта строка читается так: переменной C присваиваем значение a + b . Точка с запятой в конце означает конец строки в делфи.

Для вычитания используется знак «-» без кавычек, для умножения «*», для деления «/». Но для формул с участием, например синуса или тангенса все обстоит немножко сложнее. Но обо всем по порядку.

Перед началом работы с математическими формулами рассмотренного выше типа первым делом нужно подключить модуль Math . Делается это в разделе uses:

Windows, Dialogs, StdCtrls, Math.

А далее мы получаем возможность использовать целый набор фунций:

1. Математические функции:

Ceil – округляет значение аргумента в большую сторону.

Exp – вычисляет экспоненту ( ex ).

Floor – округляет значение аргумента в меньшую сторону.

Frac – возвращает дробную часть аргумента.

Frexp – возвращает мантиссу и экспоненту аргумента.

Int – возвращает целую часть аргумента.

Intpower – возводит аргумент Х в целочисленную степень У.

Ldexp – вычисляет Х*2У.

Ln – вычисляет натуральный логарифм ln ( x ).

LnXP 1 – вычисляет натуральный логарифм ln ( x +1).

Log 10 – вычисляет десятичный логарифм.

Log 2 – вычисляет логариым аргумента по основанию 2.

LogN – вычисляет логарифм аргумента по основанию N .

Max – Возвращает большее из двух чисел.

Min – возвращает меньшее из двух чисел.

Pi – возвращает значение числа Пи.

Poly – вычисляет однородный полином.

Power – Возводит Х в степень У.

Round – округляет число к ближайшему целому.

Sqr – вычисляет квадрат аргумента Х.

Trunc – отсекает дробную часть числа.

2. Тригонометрические функции и процедуры.

ArcCos – вычисляет арккосинус аргумента.

ArcCosh – вычисляет гиперболический арккосинус аргумента.

ArcSin – вычисляет арксинус аргумента.

ArcSinh – вычисляет гиперболический арксинус аргумента.

ArcTan – вычисляет арктангенс аргумента.

ArcTan 2 – вычисляет arctg ( Y / X ).

ArcTanh – вычисляет гиперболический арктангенс аргумента.

Cos – вычисляет косинус аргумента.

Sosh – вычисляет гиперболический косинус аргумента.

Cotan – вычисляет котангенс аргумента.

Hypot – вычисляет длину гипотенузы прямоугольного треугольника.

Sin – вычисляет синус аргумента.

SinCos – вычисляет одновременно и синус и косинус аргумента.

Sinh – вычисляет гиперболический синус аргумента.

Tan – вычисляет тенгенс аргумента.

Tanh — вычисляет гиперболический тангенс аргумента.

3. Генерирование случайных чисел.

RandG – генерирует случайное число с отклонением по Гауссу.

Random – генерирует случайное число в зщаданном диапазоне.

Randomize – Инициализирует (подготавливает) генератор случайных чисел.

4. Преобразование тригонометрических единиц измерений.

CycleToRad – преобразование значения аргумента из циклов в радианы.

DegToRad – преобразование значения аргумента из градусов в радианы

GradToRad – преобразование значения аргумента из десятичных градусов в радианы.

RadToCycle – преобразование значения аргумента из радианов в циклы.

RadToDeg – преобразование значения аргумента из радианов в градусы.

RadToGrad – преобразование значения аргумента из радианов в десятичные градусы.

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

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

Также можно обойтись вообще без переменной а и подставить просто необходимое значение:

Подобные примеры можно повторить и с другими функциями. Теперь рассмотрим пример с возведением числа в степень. Допустим, что необходимо возвести переменную х в 3-ю степень, а результат записать в переменную b :

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

X := random (10); //генрируются значения от нуля до девяти

Y := random (10)+1; //генерируются значения от единицы до 10

Надеюсь имеющихся примеров будет достаточно для понимания сути перевода математических формул в Delphi формулы. И теперь стало ясно, что делать это не так уж и сложно. Поэтому не бойтесь пользоваться готовыми функциями для создания необходимых Delphi формул. Удачи всем в создании собственных приложений.

Math в Delphi

FastMath — Fast Math Library for Delphi

FastMath is a Delphi math library that is optimized for fast performance (sometimes at the cost of not performing error checking or losing a little accuracy). It uses hand-optimized assembly code to achieve much better performance then the equivalent functions provided by the Delphi RTL.

This makes FastMath ideal for high-performance math-intensive applications such as multi-media applications and games. For even better performance, the library provides a variety of «approximate» functions (which all start with a Fast -prefix). These can be very fast, but you will lose some (sometimes surprisingly little) accuracy. For gaming and animation, this loss in accuracy is usually perfectly acceptable and outweighed by the increase in speed. Don’t use them for scientific calculations though.

You may want to call DisableFloatingPointExceptions at application startup to suppress any floating-point exceptions. Instead, it will return extreme values (like Nan or Infinity) when an operation cannot be performed. If you use FastMath in multiple threads, you should call DisableFloatingPointExceptions in the Execute block of those threads.

Table of Contents

Most operations can be performed on both singular values (scalars) as well as vectors (consisting of 2, 3 or 4 values). SIMD optimized assembly code is used to calculate multiple outputs at the same time. For example, adding two 4-value vectors together is almost as fast as adding two single values together, resulting in a 4-fold speed increase. Many functions are written in such a way that the performance is even better.

Here are some examples of speed up factors you can expect on different platforms:

RTL FastMath x86-32 x86-64 Arm32 Arm64
TVector3D + TVector3D TVector4 + TVector4 1.2x 1.6x 2.8x 2.5x
Single * TVector3D Single * TVector4 2.2x 2.1x 5.6x 3.7x
TVector3D.Length TVector4.Length 3.0x 5.6x 19.9x 17.1x
TVector3D.Normalize TVector4.Normalize 4.1x 5.1x 7.4x 11.7x
TVector3D * TMatrix3D TVector4 * TMatrix4 1.3x 4.0x 6.5x 4.2x
TMatrix3D * TMatrix3D TMatrix4 * TMatrix4 2.2x 7.2x 5.4x 8.0x
TMatrix3D.Inverse TMatrix4.Inverse 9.8x 9.2x 8.0x 9.8x
Sin(Single) (x4) FastSin(TVector4) 14.8x 7.7x 42.6x 40.1x
SinCos(Single) (x4) FastSinCos(TVector4) 19.1x 9.0x 67.9x 93.3x
Exp2(Single) (x4) FastExp2(TVector4) 22.4x 32.7x 275.0x 302.4x

As you can see, some very common (3D) operations like matrix multiplication and inversion can be almost 10 times faster than their corresponding RTL versions. In addition, FastMath includes a number of Fast* approximation functions that sacrifice a little accuracy for an enormous speed increase. For example, using FastSinCos to calculate 4 sine and cosine functions in parallel can be up to 90 times faster than calling the RTL SinCos function 4 times, while still providing excellent accuracy for angles up to +/4000 radians (or +/- 230,000 degrees).

On 32-bit and 64-bit desktop platforms (Windows and OS X), this performance is achieved by using the SSE2 instruction set. This means that the computer must support SSE2. However, since SSE2 was introduced back in 2001, the vast majority of computers in use today will support it. All 64-bit desktop computers have SSE2 support by default. However, you can always compile this library with the FM_NOSIMD define to disable SIMD optimization and use plain Pascal versions. This can also be useful to compare the speed of the Pascal versions with the SIMD optimized versions.

On 32-bit mobile platforms (iOS and Android), the NEON instruction set is used for SIMD optimization. This means that your device needs to support NEON. But since Delphi already requires this, this poses no further restrictions.

On 64-bit mobile platforms (iOS), the Arm64/AArch64 SIMD instruction set is used.

There is no hardware accelerated support for the iOS simulator (it will use Pascal versions for all calculations).

Architecture and Design Decisions

FastMath operations on single-precision floating-point values only. Double-precision floating-point arithmetic is (currently) unsupported.

Most functions operate on single values (of type Single ) and 2-, 3- and 4-dimensional vectors (of types TVector2 , TVector3 and TVector4 respectively). Vectors are not only used to represent points or directions in space, but can also be regarded as arrays of 2, 3 or 4 values that can be used to perform calculations in parallel. In addition to floating-point vectors, there are also vectors that operator on integer values ( TIVector2 , TIVector3 and TIVector4 ).

There is also support for 2×2, 3×3 and 4×4 matrices (called TMatrix2 , TMatrix3 and TMatrix4 ). By default, matrices are stored in row-major order, like those in the RTL’s System.Math.Vectors unit. However, you can change this layout with the FM_COLUMN_MAJOR define. This will store matrices in column-major order instead, which is useful for OpenGL applications (which work best with this layout). In addition, this define will also clip the depth of camera matrices to -1..1 instead of the default 0..1. Again, this is more in line with the default for OpenGL applications.

For representing rotations in 3D space, there is also a TQuaternion , which is similar to the RTL’s TQuaternion3D type.

The operation of the library is somewhat inspired by shader languages (such as GLSL and HLSL). In those languages you can also treat single values and vectors similarly. For example, you can use the Sin function to calculate a single sine value, but you can also use it with a TVector4 type to calculate 4 sine values in one call. When combined with the approximate Fast* functions, this can result in an enormous performance boost, as shown earlier.

All vector and matrix types support overloaded operators which allow you to negate, add, subtract, multiply and divide scalars, vectors and matrices.

There are also overloaded operators that compare vectors and matrices for equality. These operators check for exact matches (like Delphi’s = operator). They don’t allow for very small variations (like Delphi’s SameValue functions).

The arithmetic operators + , — , * and / usually work component-wise when applied to vectors. For example if A and B are of type TVector4 , then C := A * B will set C to (A.X * B.X, A.Y * B.Y, A.Z * B.Z, A.W * B.W) . It will not perform a dot or cross product (you can use the Dot and Cross functions to compute those).

For matrices, the + and — operators also operate component-wise. However, when multiplying (or dividing) matrices with vectors or other matrices, then the usual linear algebraic multiplication (or division) is used. For example:

  • M := M1 * M2 performs a linear algebraic matrix multiplication
  • V := M1 * V1 performs a matrix * row vector linear algebraic multiplication
  • V := V1 * M1 performs a column vector * matrix linear algebraic multiplication

To multiply matrices component-wise, you can use the CompMult method.

Interoperability with the Delphi RTL

FastMath provides its own vector and matrix types for superior performance. Most of them are equivalent in functionality and data storage to the Delphi RTL types. You can typecast between them or implicitly convert from the FastMath type to the RTL type or vice versa (eg. MyVector2 := MyPointF ). The following table shows the mapping:

Purpose FastMath Delphi RTL
2D point/vector TVector2 TPointF
3D point/vector TVector3 TPoint3D
4D point/vector TVector4 TVector3D
2×2 matrix TMatrix2 N/A
3×3 matrix TMatrix3 TMatrix
4×4 matrix TMatrix4 TMatrix3D
quaternion TQuaternion TQuaternion3D

Documentation can be found in the HTML Help file FastMath.chm in the Doc directory.

The FastMath repository hold the following directories:

  • Doc : documentation in HtmlHelp format. Also contains a spreadsheet (Benchmarks.xlsx) with results of performance tests on my devices (a Core i7 desktop and iPad3).
  • DocSource : contains batch files for generating the documentation. You need PasDocEx to generate the documentation yourself if you want to.
  • FastMath : contains the main Neslib.FastMath unit as well as various include files with processor specific optimizations, and static libraries with Arm optimized versions for iOS and Android.
    • Arm : Arm specific source code and scripts.
      • Arm32 : contains the assembly source code for Arm Neon optimized functions.
      • Arm64 : contains the assembly source code for Arm64 optimized functions.
      • fastmath-android : contains a batch file and helper files to build the static library for Android using the Android NDK.
      • fastmath-ios : contains a macOS shell script to build a universal static library for iOS.
  • Tests : contains a FireMonkey application that runs unit tests and performance tests.

FastMath is licensed under the Simplified BSD License. Some of its functions are based on other people’s code licensed under the MIT, New BSD and ZLib licenses. Those licenses are as permissive as the Simplified BSD License used for the entire project.

Илон Маск рекомендует:  Альтернативный текст
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL