平方根

最新推荐文章于 2023-09-16 01:18:17 发布
最新推荐文章于 2023-09-16 01:18:17 发布
阅读量1.2k 收藏
点赞数
分类专栏： 信息学奥赛


任意数的平方根.

1的平方根是1

2的平方根是1.4


C++：

/*          Code written by Sanchit Karve
                  A.K.A born2c0de
                  Contact Me at born2c0de AT hotmail.com

                  20 August, 2005

*/
From: http://www.dreamincode.net/code/snippet244.htm


#include <iostream>
#include <math.h>

using namespace std;

float sqroot(float m)
{
     float i=0;
     float x1,x2;
     while( (i*i) <= m )
               i+=0.1;
     x1=i;
     for(int j=0;j<10;j++)
     {
          x2=m;
          x2/=x1;
          x2+=x1;
          x2/=2;
          x1=x2;
     }
     return x2;
}

int main()
{
   cout<<"Enter a Number:";
   int no;
   cin>>no;
   cout<<"Square Root using sqroot()= "<<sqroot(no)<<endl
       <<"Square Root using sqrt()  = "<<sqrt(no);

   return 0;
}



Java:

1.古人算法（暴力法）  

原理：从0开始0.00001,000002...一个一个试，直到找到x的平方根，代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double baoliSqrt(double x) {  
  4.   
  5.         final double _JINGDU = 1e-6;  
  6.         double i;  
  7.         for (i = 0; Math.abs(x - i * i) > _JINGDU; i += _JINGDU)  
  8.             ;  
  9.         return i;  
  10.     }  
  11.   
  12.     public static void main(String[] args) {  
  13.         double x = 3;  
  14.         double root = baoliSqrt(x);  
  15.         System.out.println(root);  
  16.     }  
  17. }  

测试结果：

1.7320509999476947

2.牛顿迭代法

计算机科班出身的童鞋可能首先会想到的是《数值分析》中的牛顿迭代法求平方根。原理是：随意选一个数比如说8，要求根号3，我们可以这么算：

(8 + 3/8) = 4.1875

(4.1875 + 3/4.1875) = 2.4519

(2.4519 + 3/2.4519) = 1.837

(1.837 + 3/1.837) = 1.735

做了4步基本算出了近似值了，这种迭代的方式就是传说中的牛顿迭代法了，代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double newtonSqrt(double x) {  
  4.   
  5.         if (x < 0) {  
  6.             System.out.println("负数没事开什么方");  
  7.             return -1;  
  8.         }  
  9.         if (x == 0)  
  10.             return 0;  
  11.   
  12.         double _avg = x;  
  13.         double last_avg = Double.MAX_VALUE;  
  14.         final double _JINGDU = 1e-6;  
  15.   
  16.         while (Math.abs(_avg - last_avg) > _JINGDU) {  
  17.             last_avg = _avg;  
  18.             _avg = (_avg + x / _avg) / 2;  
  19.         }  
  20.         return _avg;  
  21.     }  
  22.   
  23.     public static void main(String[] args) {  
  24.         double x = 3;  
  25.         double root = newtonSqrt(x);  
  26.         System.out.println(root);  
  27.     }  
  28. }  

测试结果：

1.7320508075688772


3.暴力-牛顿综合法

原理：还是以根号3为例，先用暴力法讲根号3逼近到1.7，然后再利用上述的牛顿迭代法。虽然没有用牛顿迭代好，但是也为我们提供一种思路。代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double baoliAndNewTonSqrt(double x) {  
  4.       
  5.         if (x < 0) {  
  6.             System.out.println("负数没事开什么方");  
  7.             return -1;  
  8.         }  
  9.         if (x == 0)  
  10.             return 0;  
  11.   
  12.         double i = 0;  
  13.         double _avg;  
  14.         double last_avg = Double.MAX_VALUE;  
  15.         for (i = 0; i*i < x; i += 0.1);  
  16.         _avg = i;  
  17.   
  18.         final double _JINGDU = 1e-6;  
  19.   
  20.         while (Math.abs(_avg - last_avg) > _JINGDU) {  
  21.             last_avg = _avg;  
  22.             _avg = (_avg + x / _avg) / 2;  
  23.         }  
  24.         return _avg;  
  25.     }  
  26.       
  27.     public static void main(String[] args) {  
  28.         double x = 3;  
  29.         double root = baoliAndNewTonSqrt(x);  
  30.         System.out.println(root);  
  31.     }  
  32. }  

测试结果：

1.7320508075689423


4.二分开方法

原理：还是以3举例：

(0+3)/2 = 1.5, 1.5^2 = 2.25, 2.25 < 3;

(1.5+3)/2 = 2.25, 2.25^2 = 5.0625, 5.0625 > 3;

(1.5+2.25)/2 = 1.875, 1.875^2 = 3.515625; 3.515625>3;

.

.

.

直到前后两次平均值只差小于自定义精度为止，代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double erfenSqrt(double x) {  
  4.   
  5.         if (x < 0) {  
  6.             System.out.println("负数没事开什么方");  
  7.             return -1;  
  8.         }  
  9.         if (x == 0)  
  10.             return 0;  
  11.   
  12.         final double _JINGDU = 1e-6;  
  13.         double _low = 0;  
  14.         double _high = x;  
  15.         double _mid = Double.MAX_VALUE;  
  16.         double last_mid = Double.MIN_VALUE;  
  17.   
  18.         while (Math.abs(_mid - last_mid) > _JINGDU) {  
  19.   
  20.             last_mid = _mid;  
  21.             _mid = (_low + _high) / 2;  
  22.             if (_mid * _mid > x)  
  23.                 _high = _mid;  
  24.             if (_mid * _mid < x)  
  25.                 _low = _mid;  
  26.   
  27.         }  
  28.         return _mid;  
  29.   
  30.     }  
  31.   
  32.     public static void main(String[] args) {  
  33.         double x = 3;  
  34.         double root = erfenSqrt(x);  
  35.         System.out.println(root);  
  36.     }  
  37. }  

测试结果：

1.732051134109497


5.计算 (int)(sqrt(x))算法

PS:此算法非博主所写
原理：空间换时间，细节请大家自行探究，代码如下：

[java]  view plain  copy
  1. public class APIsqrt2 {  
  2.     final static int[] table = { 0, 16, 22, 27, 32, 35, 39, 42, 45, 48, 50, 53,  
  3.             55, 57, 59, 61, 64, 65, 67, 69, 71, 73, 75, 76, 78, 80, 81, 83, 84,  
  4.             86, 87, 89, 90, 91, 93, 94, 96, 97, 98, 99, 101, 102, 103, 104,  
  5.             106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119,  
  6.             120, 121, 122, 123, 124, 125, 126, 128, 128, 129, 130, 131, 132,  
  7.             133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 144,  
  8.             145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,  
  9.             156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166,  
  10.             167, 167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175, 176,  
  11.             176, 177, 178, 178, 179, 180, 181, 181, 182, 183, 183, 184, 185,  
  12.             185, 186, 187, 187, 188, 189, 189, 190, 191, 192, 192, 193, 193,  
  13.             194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201, 202,  
  14.             203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210,  
  15.             211, 211, 212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218,  
  16.             218, 219, 219, 220, 221, 221, 222, 222, 223, 224, 224, 225, 225,  
  17.             226, 226, 227, 227, 228, 229, 229, 230, 230, 231, 231, 232, 232,  
  18.             233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 240,  
  19.             240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246,  
  20.             247, 247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253,  
  21.             253, 254, 254, 255 };  
  22.   
  23.     /** 
  24.      * A faster replacement for (int)(java.lang.Math.sqrt(x)). Completely 
  25.      * accurate for x < 2147483648 (i.e. 2^31)... 
  26.      */  
  27.     static int sqrt(int x) {  
  28.         int xn;  
  29.   
  30.         if (x >= 0x10000) {  
  31.             if (x >= 0x1000000) {  
  32.                 if (x >= 0x10000000) {  
  33.                     if (x >= 0x40000000) {  
  34.                         xn = table[x >> 24] << 8;  
  35.                     } else {  
  36.                         xn = table[x >> 22] << 7;  
  37.                     }  
  38.                 } else {  
  39.                     if (x >= 0x4000000) {  
  40.                         xn = table[x >> 20] << 6;  
  41.                     } else {  
  42.                         xn = table[x >> 18] << 5;  
  43.                     }  
  44.                 }  
  45.   
  46.                 xn = (xn + 1 + (x / xn)) >> 1;  
  47.                 xn = (xn + 1 + (x / xn)) >> 1;  
  48.                 return ((xn * xn) > x) ? --xn : xn;  
  49.             } else {  
  50.                 if (x >= 0x100000) {  
  51.                     if (x >= 0x400000) {  
  52.                         xn = table[x >> 16] << 4;  
  53.                     } else {  
  54.                         xn = table[x >> 14] << 3;  
  55.                     }  
  56.                 } else {  
  57.                     if (x >= 0x40000) {  
  58.                         xn = table[x >> 12] << 2;  
  59.                     } else {  
  60.                         xn = table[x >> 10] << 1;  
  61.                     }  
  62.                 }  
  63.   
  64.                 xn = (xn + 1 + (x / xn)) >> 1;  
  65.   
  66.                 return ((xn * xn) > x) ? --xn : xn;  
  67.             }  
  68.         } else {  
  69.             if (x >= 0x100) {  
  70.                 if (x >= 0x1000) {  
  71.                     if (x >= 0x4000) {  
  72.                         xn = (table[x >> 8]) + 1;  
  73.                     } else {  
  74.                         xn = (table[x >> 6] >> 1) + 1;  
  75.                     }  
  76.                 } else {  
  77.                     if (x >= 0x400) {  
  78.                         xn = (table[x >> 4] >> 2) + 1;  
  79.                     } else {  
  80.                         xn = (table[x >> 2] >> 3) + 1;  
  81.                     }  
  82.                 }  
  83.   
  84.                 return ((xn * xn) > x) ? --xn : xn;  
  85.             } else {  
  86.                 if (x >= 0) {  
  87.                     return table[x] >> 4;  
  88.                 }  
  89.             }  
  90.         }  
  91.   
  92.         return -1;  
  93.     }  
  94.     public static void main(String[] args){  
  95.         System.out.println(sqrt(65));  
  96.           
  97.     }  
  98. }  
测试结果：8


6.最快的sqrt算法

PS:此算法非博主所写

这个算法很有名，大家可能也见过，作者是开发游戏的，图形算法中经常用到sqrt，作者才写了一个神级算法，和他那神秘的0x5f3759df，代码如下

[cpp]  view plain  copy
  1. #include <math.h>  
  2. float InvSqrt(float x)  
  3. {  
  4.  float xhalf = 0.5f*x;  
  5.  int i = *(int*)&x; // get bits for floating VALUE  
  6.  i = 0x5f375a86- (i>>1); // gives initial guess y0  
  7.  x = *(float*)&i; // convert bits BACK to float  
  8.  x = x*(1.5f-xhalf*x*x); // Newton step, repeating increases accuracy  
  9.  return x;  
  10. }  
  11.   
  12. int main()  
  13. {  
  14.   printf("%lf",1/InvSqrt(3));  
  15.   
  16.    return 0;  
  17. }  
测试结果：


感兴趣的朋友可以参考http://wenku.baidu.com/view/a0174fa20029bd64783e2cc0.html  是作者解释这个算法的14页论文《Fast Inverse Square Root》


7.一个与算法6相似的算法

PS:此算法非博主所写

代码如下：

[cpp]  view plain  copy
  1. #include <math.h>  
  2. float SquareRootFloat(float number) {  
  3.     long i;  
  4.     float x, y;  
  5.     const float f = 1.5F;  
  6.   
  7.     x = number * 0.5F;  
  8.     y  = number;  
  9.     i  = * ( long * ) &y;  
  10.     i  = 0x5f3759df - ( i >> 1 );  
  11.     y  = * ( float * ) &i;  
  12.     y  = y * ( f - ( x * y * y ) );  
  13.     y  = y * ( f - ( x * y * y ) );  
  14.     return number * y;  
  15. }  
  16.   
  17. int main()  
  18. {  
  19.   printf("%f",SquareRootFloat(3));  
  20.   
  21.    return 0;  
  22. }  
测试结果：



greatau
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MATLAB平方根发程序代码
02-06
平方根的MATLAB代码实现，平方根，又叫二次方根，表示为〔±√￣〕，其中属于非负数的平方根称之为算术平方根（arithmetic square root）。一个正数有两个实平方根，它们互为相反数；0只有一个平方根，就是0本身；负数有两个共轭的纯虚平方根。[1] 一般地，“√￣”仅用来表示算术平方根，即非负数的非负平方根。如：数学语言为：√￣16=4。语言描述为：根号下16=4（也可叫根号16=4）。
Lua 基础之运算符
xingxinmanong的博客
07-17 9405
算术运算符lua 的算术运算符有加减乘除、n次方（或开方）、求余等。
Lua_Math标准库
青青子衿
04-15 946
local num = 0; --获得圆周率 print(math.pi) --求绝对值 print(math.abs(-15)) --向上取余，也就是只要有小数点，都进位 print(math.ceil(3.17)) --向下取余，也就是只要有小数点，都舍去小数位 print(math.floor(3.15)) --求模，也就是求余 print(math.mod(7, 3)) --求
lua 的常用math 函数
ooomyself的博客
12-28 4204
math.sqrt() -- 开平方 -- math.ceil() 取整函数local num = math.ceil(33.33333)
python求平方根的代码_python求平方根的方法
weixin_26712065的博客
02-21 8109
python求平方根的方法发布时间：2020-08-13 14:52:09来源：亿速云阅读：87作者：小新这篇文章给大家分享的是有关python求平方根的方法的内容。小编觉得挺实用的，因此分享给大家做个参考。一起跟随小编过来看看吧。平方根，又叫二次方根，表示为〔√￣〕，如：数学语言为：√￣16=4。语言描述为：根号下16=4。以下实例为通过用户输入一个数字，并计算这个数字的平方根：例如#-*-...
平方根_java计算平方根_
09-29
在Java编程语言中，计算平方根是一项常见的数学运算，它被广泛应用于各种算法和数学问题中。本节将深入探讨如何使用Java来计算一个数的平方根，以及相关的数学概念和技术。 首先，Java提供了多种方法来计算平方根。...
matlab平方根法和改进平方根法求解线性方程组例题与程序文件.docx
06-24
《MATLAB中的平方根法与改进平方根法求解线性方程组》 线性方程组的求解在科学计算中占有重要的地位，MATLAB作为一种强大的数值计算工具，提供了多种方法来解决这类问题。本文主要探讨的是利用MATLAB实现的平方根法...
python之二分法求平方根
12-22
前几天学完python的程序分支结构后，老师课后留了一个问题，用两种方法计算一个大于或等于 1 的实数 n 数的平方根。 描述 设计一个用二分法计算一个大于或等于 1 的实数 n 的平方根的函数sqrt_binary(n)，计算精度...
Python求解平方根的方法
09-22
主要介绍了Python求解平方根的方法,涉及Python数学运算的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
平方根法解方程组
03-19
平方根法，也称为Cholesky分解法，是数值线性代数中的一种高效算法，主要用于求解对称正定的线性方程组。在数值分析课程中，平方根法因其计算效率高和稳定性好而备受关注。该方法通过将系数矩阵A分解为LL^T的形式（L...
jisuanqi.zip_实数平方根
09-24
在计算机科学中，计算平方根是一项基础且重要的任务，特别是在数值计算领域。"jisuanqi.zip_实数平方根"这个压缩包中的程序段显然关注的是如何高效且精确地求解实数的平方根。迭代法是求解这类问题的常见方法之一，...
matlab平方根法和改进平方根法求解线性方程组例题与程序文件.pdf
05-25
《MATLAB中的平方根法与改进平方根法求解线性方程组》 线性方程组的求解在科学计算中占有重要地位，MATLAB作为一种强大的数值计算工具，提供了多种方法来解决这类问题。本文主要探讨的是利用MATLAB实现的平方根法和...
Python基于二分查找实现求整数平方根的方法
09-21
而当我们需要计算一个非负整数的平方根时，也可以利用二分查找的思想来实现。这种方法通常比直接使用内置的数学函数（如math.sqrt()）更快，尤其是在处理大数据量的情况下。 首先，理解二分查找的基本原理。二分...
MATLAB-平方根法和改进平方根法求解线性方程组例题与程序演示教学.pdf
04-04
平方根法和改进平方根法是两种用于求解线性方程组的高效算法，尤其适用于处理对称正定矩阵的线性系统。这两种方法基于矩阵的分解，减少了计算复杂度，提高了求解效率。 首先，平方根法，也称为Cholesky分解，是一种...
vb编写的平方根算法
11-27
用vb编写的平方根算法，对于学习计算方法有一定帮助，这个小程是用vb编写的平方根算法源码，可以执行，有利于学习VB及深入理解计算方法。
Python求平方根
最新发布
weixin_44074100的博客
09-16 5748
有时候math模块无法使用，这时候就需要使用自带的内置函数pow()
python怎么用根号_python如何开根号
weixin_39699670的博客
11-20 1726
平方根，又叫二次方根，表示为〔√￣〕，如：数学语言为：√￣16=4。语言描述为：根号下16=4。python学习网，大量的免费python基础教程，欢迎在线学习！以下实例为通过用户输入一个数字，并计算这个数字的平方根：例如num = float(input('请输入一个数字： '))num_sqrt = num ** 0.5print(' %0.3f 的平方根为 %0.3f'%(num ,num_...
c语言计算平方根编程程序,一个用C语言计算平方根的巧妙算法
weixin_39755853的博客
05-18 6701
#include void main(){int w,i;double ss;double x, y;printf("enter the number!\n");scanf("%lf",&y); /* 输入浮点型数据Y，即我们要求平方根的方程 */x=y; /* 这里把Y赋给X是想把Y的值先保存下来 */ss=1.0;for(w=0;x>=1;w++){x...
Lua语言基础
weixin_45655585的博客
02-05 162
LUA语言基础。
平方根verilog
07-27
在 Verilog 中，可以使用内置函数 `$sqrt()` 来计算一个数的平方根。以下是一个计算平方根的例子： ```verilog module sqrt_example; reg [31:0] input; reg [31:0] output; initial begin input = 16; // ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值