Как составить программу для вычисления квадратный корень - Исправление недочетов и поиск решений вместе с Examum.ru

В прошлом уроке мы рассматривали операторы сложения, вычитания, умножения и деления. Сегодня я предлагаю рассмотреть операторы квадрата, корня и модуля.

1. Оператор квадрата

Этот оператор возводит в квадрат заданное ему число или переменную. Обозначается, как «sqr» без кавычек. В программе пишется как sqr(a), где a — любая другая переменная или число.

Пример:

var a, c:integer;
begin
  writeln ('Введите число');
  readln (a);
  c:=sqr(a);
  writeln ('Квадрат равен ',c);
end.

2. Оператор корня

Этот оператор находит корень из переменной или числа. Обозначается, как «sqrt» , без кавычек. В программе пишется как sqrt(a), где a — любая другая переменная или число.

Пример:

var a, c:real;
begin
  writeln ('Введите число');
  readln (a);
  c:=sqrt(a);
  writeln ('Корень равен ',c);
end.

3. Оператор модуля

Данный оператор переводит число из обычного в число по модулю, то есть меняет его знак всегда на положительный. Обозначается, как «abs» без кавычек, в программе пишется, как abs(a), где a — любое число или другая переменная.

Пример:

var a, c:real;
begin
  writeln ('Введите число');
  readln (a);
  c:=abs(a);
  writeln ('Модуль равен ',c);
end.

На сегодня урок окончен, с другими уроками вы можете познакомиться в категории «Уроки паскаль»

Дата: 2011-12-18 19:47:31 Просмотров: 140030

Теги: Паскаль уроки Pascal

Источник

Improve Article

Save Article

Like Article

Read

Discuss

Improve Article

Save Article

Like Article

Given a number N, the task is to write a C program to find the square root of the given number N.

Examples:

Input: N = 12
Output: 3.464102

Input: N = 16
Output: 4

Method 1: Using inbuilt sqrt() function: The sqrt() function returns the sqrt of any number N.

Below is the implementation of the above approach:

C

#include <math.h>

#include <stdio.h>

double findSQRT(double N) { return sqrt(N); }

int main()

{

int N = 12;

printf("%f ", findSQRT(N));

return 0;

}

Time complexity: O(logN), as the inbuilt sqrt() function take log(n)
Auxiliary space: O(1)

Method 2: Using Binary Search: This approach is used to find the square root of the given number N with precision upto 5 decimal places.

The square root of number N lies in range 0 ≤ squareRoot ≤ N. Initialize start = 0 and end = number.
Compare the square of the mid integer with the given number. If it is equal to the number, then we found our integral part, else look for the same in the left or right side of mid depending upon the condition.
After finding an integral part, we will find the fractional part.
Initialize the increment variable by 0.1 and iteratively calculate the fractional part upto 5 decimal places.
For each iteration, change increment to 1/10th of its previous value.
Finally, return the answer computed.

Below is the implementation of the above approach:

C

#include <stdio.h>

#include <stdlib.h>

float findSQRT(int number)

{

int start = 0, end = number;

int mid;

float ans;

while (start <= end) {

mid = (start + end) / 2;

if (mid * mid == number) {

ans = mid;

break;

}

if (mid * mid < number) {

ans=start;

start = mid + 1;

}

else {

end = mid - 1;

}

float increment = 0.1;

for (int i = 0; i < 5; i++) {

while (ans * ans <= number) {

ans += increment;

}

ans = ans - increment;

increment = increment / 10;

}

return ans;

}

int main()

{

int N = 12;

printf("%f ", findSQRT(N));

return 0;

}

Method 3: Using log2(): The square-root of a number N can be calculated using log2() as:

Let d be our answer for input number N, then

$d = N^{frac{1}{2}}$

Apply log2() both sides

$log2(d) = log2(N^{frac{1}{2}})$

$log2(d) = {frac{1}{2}}*log2(N)$

$d = 2^{{frac{1}{2}}*log2(N)}$

Therefore,

d = pow(2, 0.5*log2(n))

Below is the implementation of the above approach:

C

#include <math.h>

#include <stdio.h>

double findSQRT(double N) { return pow(2, 0.5 * log2(N)); }

int main()

{

int N = 12;

printf("%f ", findSQRT(N));

return 0;

}

Last Updated :
23 Nov, 2022

Like Article

Save Article

Источник

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

Основы программирования
Каждый профессионал когда-то был чайником. Наверняка вам знакомо состояние, когда “не знаешь как начать думать, чтобы до такого додуматься”. Наверняка вы сталкивались с ситуацией, когда вы просто не знаете, с чего начать.
Эта книга ориентирована как раз на таких людей, кто хотел бы стать программистом, но совершенно не знает, как начать этот путь.
Подробнее…

Функция Sqrt в Паскале вычисляет квадратный корень числа. Синтаксис функции следующий:

function Sqrt(Х : ValReal) : ValReal;

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

Функция Sqr в Паскале вычисляет квадрат числа. Синтаксис функции для разных типов приведён ниже:

function Sqr(Х : LongInt) : LongInt;

function Sqr(Х : QWord) : QWord;

function Sqr(Х : ValReal) : ValReal;

Эта функция возвращает результат вычисления квадрата числа, переданного через параметр. То есть Sqr = х * х.

О типе ValReal я рассказывал здесь.

Квадрат числа

Здесь всё крайне просто. Квадрат числа Х равен произведению Х на Х. То есть функция Sqr на первый взгляд кажется бесполезной. Потому что во многих случаях проще написать так:

Х := Х * Х

чем

Х := Sqr(X)

Единственный случай, когда использование функции Sqr является обоснованным с точки
зрения упрощения кода, это когда в качестве параметра передаётся вещественное число
(константа) с большим количеством знаков после запятой, или очень большое целое число, или сложное выражение. Например:

Х := Sqr(5.3456753322)

будет написать проще, чем

Х := 5.3456753322 * 5.3456753322

Также возведение в квадрат числа в Паскале сложного выражения тоже будет проще, если использовать функцию Sqr:

X := Sqr(Y + 100 * Z / X)

Вычисление квадратного корня

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

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

Эту функцию вы уже знаете — это функция Sqrt.

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

Итак, квадратный корень из числа А (корень 2-й степени) — это решение уравнения:

Х² = А

То есть квадратный корень из числа А, это число Х, которое при возведении в квадрат даёт число А.

То есть если

Х * Х = √А

то

Х = А

ВАЖНО!
Число А может быть только положительным числом. Извлечение корня из отрицательного числа тоже возможно, но это уже будут комплексные числа.

Как стать программистом 2.0

Эта книга для тех, кто хочет стать программистом. На самом деле хочет, а не просто мечтает. И хочет именно стать программистом с большой буквы, а не просто научиться кулебякать какие-то примитивные программки…
Подробнее…

Помощь в технических вопросах

Помощь студентам. Курсовые, дипломы, чертежи (КОМПАС), задачи по программированию: Pascal/Delphi/Lazarus; С/С++; Ассемблер; языки программирования ПЛК; JavaScript; VBScript; Fortran; Python и др. Разработка (доработка) ПО ПЛК (предпочтение — ОВЕН, CoDeSys 2 и 3), а также программирование панелей оператора, программируемых реле и других приборов систем автоматизации.
Подробнее…

Источник

Написать программу, которая вычисляет квадратный корень числа. Программа должна проверять правильность введенных пользователем данных и, если они неверные (введенное пользователем число меньше нуля), выдавать сообщение об ошибке. Ниже представлен рекомендуемый вид экрана во время работы программы (данные, введенные пользователем, выделены полужирным шрифтом).
Вычисление квадратного корня.
Введите число и нажмите <Enter>
= — 16
Вы ошиблись. Введенное число меньше нуля.

Добавлено через 4 часа 47 минут
ребят что не кто не чем помочь не может?

Источник

Вычисление квадратного корня из целого числа

Представленный алгоритм был создан в те
бородатые времена, когда производительность x87
оставляла желать лучшего. Но и сейчас, скорость
работы этого алгоритма соизмерима со скоростью
вычисления с плавающей точкой на PII или MMX. На мой
взгляд, материал может быть интересен, как
начинающим программистам — пусть учатся писать
программы, а не ломать их, и не вирусы, так и
опытным — как игра ума., скомпилированный MSVC 5.0, на
PII-233×2 дает следующие результаты (Листинг 1):

testing with range[0..1000]
Done.
testing range1=[0..1000]...
fpu1...
cpu1...
cpu2...
testing range2=[1000..10000]...
fpu1...
cpu1...
cpu2...
testing range3=[10000..100000]...
fpu1...
cpu1...
cpu2...
Done.
range            fpu1    cpu1    cpu2
1000            1.000   3.000   3.000
10000           1.000   3.000   4.000
100000          1.000   3.000   5.000

Задача вычисления квадратного корня при
построении программ достаточна тривиальная.
Функция для ее решения — sqrt — присутствует
практически в любом из современных языков
программирования. Однако практика использования
функции sqrt показала, что данная функция ведет
себя совершенно различным способом для
целочисленных и действительных аргументов.

Пример 1

#include <stdio.h>
#include <math.h>
void main( )
{
      int i = 169, j = 168;
      printf(
            <sqrt(%d)=%d, sqrt(%d)=%d>,
            i, (int)sqrt(i),
            j, (int)sqrt(j)
      );
}

Результат выполнения кода приведенного в
примере 1 выглядит так:

sqrt(169)=13, sqrt(168)=12

В действительности, значение квадратного корня
для числа 168 соответствует числу 12.96, что по
общепринятым правилам округления ближе к целому
числу 13. В данном примере мы видим классический
машинный случай округления с отбрасыванием
дробной части.

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

Пример 2

unsigned sqrt_fpu_true(long l)
{
      unsigned rslt;
      double f_rslt = 0;
      if (l <= 0)
            return 0;
      f_rslt = sqrt(l);
      rslt = (int)f_rslt;
      if (!(f_rslt - rslt < .5))
            rslt ++;
      return rslt;
}

Функция, приведенная в примере 2, дает абсолютно
правильные значения для всех целых чисел
согласно принятым правилам округления. Однако
возникает вопрос: возможно ли получение
правильных результатов при использовании
целочисленных алгоритмов?

Самый известный целочисленный алгоритм для
вычисления квадратного корня из числа поражает
своей простотой и приведен в примере 3.

Пример 3

unsigned sqrt_cpu_int(long l)
{     unsigned div = 1, rslt = 0;
      while (l > 0)
      {
            l -=  div, div += 2;
            rslt  += l < 0 ? 0 : 1;
      }
      return rslt;
}

Результат работы алгоритма из примера 3
идентичен результату из примера 1 — отбрасывание
дробной части. Кроме того, невооруженным глазом
виден еще один недостаток данного алгоритма —
количество итераций в цикле соответствует
значению вычисленного квадратного корня от
аргумента L:

iteration count ~= sqrt(L) (1).

Рассматривая задачу вычисления квадратного
корня с точки зрения уменьшения величины
вычислительных затрат, более привлекателен
целочисленный алгоритм, реализующий формулу
Ньютона — пример 4.

Пример 4

unsigned sqrt_cpu_newton(long l)
{
      unsigned rslt = (unsigned)l;
      long div = l;
      if (l <= 0)
            return 0;
      while (1)
      {
            div =  (l / div + div) / 2;
            if (rslt > div)
                   rslt = (unsigned)div;
            else
                   return rslt;
      }
}

Количество итераций в цикле для алгоритма из
примера 4 приблизительно будет равняться
натуральному логарифму от аргумента L:

iteration count ~= ln(L) (2).

Легко заключить, что разница в значениях формул
(1) и (2) достаточно велика особенно для больших
чисел, что и иллюстрирует ниже приведенная
таблица.

Число L sqrt_cpu_int    sqrt_cpu_newton
70000       264              11
300000      574              13
700000      836              13
990000      994              14

Однако результат работы алгоритма из примера 4
опять тот же — округление до целого числа
отбрасыванием дробной части. Анализ кода
алгоритма показывает, что наибольшая ошибка при
вычислениях накапливается в главной формуле
алгоритма и возникает при целочисленном делении
на 2 без учета остатка от деления. В примере 5
приведен модифицированный алгоритм вычисления
квадратного корня, с учетом вышеупомянутого
замечания.

Пример 5

unsigned sqrt_cpu_newton(long l)
{      long temp, div = l;
      unsigned rslt = (unsigned)l;
      if (l <= 0)
            return 0;
      while (1)
      {
            temp = l /  div + div;
            div = temp  >>  1;
            div += temp &  1;
            if (rslt >  div)
                  rslt  = (unsigned)div;
            else
                  return  rslt;
      }
}

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

Число             2   6  12  20  30  42  56  72  90  110  132
Действит.корень 1,4 2,4 3,4 4,4 5,4 6,4 7,4 8,4 9,4 10,4 11,4
Целый корень      1   2   3   4   5   6   7   8   9   10   11
Вычисл.корень     2   3   4   5   6   7   8   9  10   11   12

Для всех аргументов алгоритма из приведенного
ряда характерно, что вычисленное алгоритмом
значение — есть целочисленный множитель,
произведение которого с истинным целочисленным
значением квадратного корня от аргумента дает
сам аргумент. Знание выявленной закономерности
позволяет сделать последнюю модификацию
алгоритма, позволяющую окончательно устранить
ошибки в вычислениях. Модификация заключается в
проверке условия для выполнения коррекции
результата вычисления при завершении работы
алгоритма — пример 6.

Пример 6

unsigned sqrt_cpu_newton(long l)
{
      long temp, div = l;
      unsigned rslt = (unsigned)l;
      if (l <= 0)
            return 0;
      while (1)
      {
            temp = l  / div + div;
            div =  temp >>  1;
            div += temp  & 1;
            if  (rslt > div)
                   rslt = (unsigned)div;
            else
            {
                  if (l / rslt == rslt - 1 && l % rslt == 0)
                        rslt-;
                  return rslt;
            }
      }
}

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

В заключении следует отметить о существовании
еще одной модификации алгоритма. На этот раз
модификация преследует только задачу повышения
производительности алгоритма. Повысить
производительность итерационных алгоритмов
возможно только одним способом — уменьшить
количество итераций. Для приведенного в примере 6
алгоритма количество итераций можно значительно
снизить, более точно подобрав начальные значения
для переменной div — пример 7.

Пример 7

unsigned sqrt_newton(long l)
{
      long temp , div;
      unsigned  rslt = (unsigned)l;
      if (l <=  0)
            return 0;
      else if (l & 0xFFFF0000L)
            if  (l & 0xFF000000L)
                  div  = 0x3FFF;
            else
                  div  = 0x3FF;
      else
            if  (l & 0x0FF00L)
                  div  = 0x3F;
            else
                  div  = (l > 4) ? 0x7 : l;
      while (1)
      {
            temp = l  / div + div;
            div =  temp >>  1;
            div += temp  & 1;
            if  (rslt > div)
                   rslt = (unsigned)div;
            else
            {
                  if (l / rslt == rslt - 1 && l % rslt == 0)
                        rslt-;
                  return rslt;
            }
      }
}

Последняя модификация алгоритма (пример 7)
вычисляет квадратный корень из числа без ошибок
округления на диапазоне [0..10000] в среднем за 3
итерационных цикла. В таблице ниже представлена
сводная таблица по вычислительным затратам
алгоритма на исследуемом диапазоне. На других
диапазонах аргумента количество итераций не
бывает больше 6, а в среднем равняется 3. Сравнивая
с первоначально достигнутыми результатами, см.
таблицу в начале, можно сказать, что достигнуто
увеличение производительности как минимум в 2 — 4
раза.

Кол-во итераций       1       2       3       4     5   6   7
случаев из 10000      2    1965    6173    1779    80   0   0
% от всего        0,02%  19,65%  61,73%  17,19%  0,8%   0   0

Вероятно, что предел производительности
алгоритма еще не достигнут, однако данная тема не
является главной для настоящей статьи.

Листинг 1
// sqrt.cpp
#include    <stdio.h>
#include    <math.h>
#include    <time.h>
#include    <conio.h>

unsigned sqrt_fpu1(long l)
{
    if (l == 0)
        return 0;
    double f_rslt = sqrt(l);
    unsigned rslt = (int)f_rslt;
    if (!(f_rslt - rslt < .5))
        rslt ++;
    return rslt;
}

unsigned sqrt_cpu1(long l)
{
    long temp;
    unsigned div, rslt = l;
    if (l <= 0)
        return 0;
    else if (l & 0xFFFF0000L)
        if (l & 0xFF000000L)
            div = 0x3FFF;
        else
            div = 0x3FF;
    else
        if (l & 0x0FF00L)
            div = 0x3F;
        else
            div = (l > 4) ? 0x7 : l;
    while (1)
    {
        temp = l / div + div;
        div = temp >> 1;
        div += temp & 1;
        if (rslt > div)
            rslt = div;
        else
        {
            if (l / rslt == rslt - 1 && l % rslt == 0)
                rslt--;
            break;
        }
    }
    return (unsigned)rslt;
}

unsigned sqrt_cpu2(long l)
{
    if (l <= 0)
        return 0;
    long rslt = l, div = l;
    while (1)
    {
        div = (l / div + div) / 2;
        if (rslt > div)
            rslt = div;
        else
            break;
    }
    return (unsigned)rslt;
}

unsigned sqrt_cpu3(long l)
{
    unsigned div = 1;
    unsigned rslt = 0;
    while (l > 0)
    {
        l-= div, div += 2;
        rslt += l < 0 ? 0 : 1;
    }
    return rslt;
}

unsigned sqrt_cpu4(long l)
{
    unsigned div = 1, rslt = 0;
    while (l > 0)
    {
        l-= div, div += 2;
        rslt += l < 0 ? 0 : 1;
    }
    if (l != 0)
        rslt++;
    return rslt;
}

#define steps   1000
#define range1  1000L
#define range2  10000L
#define range3  100000L
#define count   2000

double times[3][3];

void CalcTime()
{
    long l;
    int i;
    time_t first, second;
    printf("testing range1=[%lu..%lu]...n", 0L, range1);
    printf("fpu1...n");
    first = time(NULL);

    for (i = 0; i < count; i++)
    for (l = 0l; l < range1; l += range1 / steps)
        sqrt_fpu1(l);
    second = time(NULL);
    times[0][0] = difftime(second, first);

    printf("cpu1...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = 0l; l < range1; l += range1 / steps)
        sqrt_cpu1(l);
    second = time(NULL);
    times[0][1] = difftime(second, first);

    printf("cpu2...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = 0l; l < range1; l += range1 / steps)
        sqrt_cpu2(l);
    second = time(NULL);
    times[0][2] = difftime(second, first);

    printf("testing range2=[%lu..%lu]...n", range1, range2);
    printf("fpu1...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = range1; l < range2; l += (range2 - range1) / steps)
        sqrt_fpu1(l);
    second = time(NULL);
    times[1][0] = difftime(second, first);

    printf("cpu1...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = range1; l < range2; l += (range2 - range1) / steps)
        sqrt_cpu1(l);
    second = time(NULL);
    times[1][1] = difftime(second, first);

    printf("cpu2...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = range1; l < range2; l += (range2 - range1) / steps)
        sqrt_cpu2(l);
    second = time(NULL);
    times[1][2] = difftime(second, first);


    printf("testing range3=[%lu..%lu]...n", range2, range3);
    printf("fpu1...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = range2; l < range3; l += (range3 - range2) / steps)
        sqrt_fpu1(l);
    second = time(NULL);
    times[2][0] = difftime(second, first);


    printf("cpu1...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = range2; l < range3; l += (range3 - range2) / steps)
        sqrt_cpu1(l);
    second = time(NULL);
    times[2][1] = difftime(second, first);


    printf("cpu2...n");
    first = time(NULL);
    for (i = 0; i < count; i++)
    for (l = range2; l < range3; l += (range3 - range2) / steps)
        sqrt_cpu2(l);
    second = time(NULL);
    times[2][2] = difftime(second, first);

    printf("Done.n");
    printf("rangett fpu1t cpu1t cpu2n");
    printf(
        "%lutt%5.3ft%5.3ft%5.3fn",
        range1,
        times[0][0],
        times[0][1],
        times[0][2]
    );
    printf(
        "%lutt%5.3ft%5.3ft%5.3fn",
        range2,
        times[1][0],
        times[1][1],
        times[1][2]
    );
    printf(
        "%lutt%5.3ft%5.3ft%5.3fn",
        range3,
        times[2][0],
        times[2][1],
        times[2][2]
    );
}

typedef unsigned (*sqrt_func)(long L);

void ViewDifferents(long rang1, long rang2, unsigned step, sqrt_func fpsqrt)
{
    unsigned long l;
    unsigned rf, ri;
    printf("testing with range[%lu..%lu]n", rang1, rang2);
    for (l = rang1; l < rang2; l += (rang2 - rang1) / step)
    {
        rf = sqrt_fpu1(l);
        ri = (*fpsqrt)(l);
        if (rf != ri)
            printf("sqrt(%lu) %u %u %6.2fn", l, rf, ri, sqrt(l));
    }
    printf("Done.n");

}

void main()
{
    ViewDifferents(0, 1000, 1000, sqrt_cpu1);
    CalcTime();

    while (!kbhit());
}

Источник