[数值计算] [代码讨论]批处理开平方(计算平方根的值)

SQYSQYSQY

致浏览者，想对大数字（超过1000）计算平方根，请见31楼（约18秒算到150位），想对小数计算平方根，请见34楼（是个文件）（约23秒算到150位）
注意，部分计算器对最后一位进行了四舍五入，本程序可能会与计算器的最后一位相差1。这不是本程序的错误。
致浏览者，被开方数不超过1000，可用下面高效率程序进行计算（约3.5秒算到150位）。

@echo off & SetLocal EnableDelayedExpansion
::变量c的值是被开方数，不得超过1000！
set c=2
for %%a in (16 8 4 2 1) do (
        set /a "d=(a*%%a<<1)+%%a*%%a+b"
        if !c! geq !d! set /a "a+=%%a","b=d"
)
if !b! equ !c! echo !a! & pause & exit /b
set /p "=!a!."<nul
set "d=0"
for %%a in (512 256 128 64 32 16 8 4 2 1) do (
        set /a "d+=%%a","e=((a*d<<1)+d*d/1000)/1000+b"
        if !e! geq !c! set /a "d-=%%a"
)
set "e=00!d!" & set /p "=!e:~-3!"<nul
set /a "e=(!a!!e:~-3!*!a!!e:~-3!)%%1000000","b=e/1000","e=e%%1000"
set "e=  !e!" & set "e=!e:~-3!"
set "b=000!e!!b!"
set "e=  !d!"
set "a=!e:~-3!!a!"
for /l %%a in (3 3 2147483646) do (
        set "d=0"
        for %%b in (512 256 128 64 32 16 8 4 2 1) do (
                set /a "d+=%%b"
                if 1000 gtr !d! (
                        set /a "c=d*d/1000"
                        for /l %%c in (0 3 %%a) do set /a "c=((!a:~%%c,3!*d<<1)+c+!b:~%%c,3!)/1000"
                        set /a "e=%%a+3"
                        for %%c in (!e!) do set /a "c+=!b:~%%c,3!" & if !c! geq 1000 set /a "d-=%%b"
                ) else set /a "d-=%%b"
        )
        set "e=00!d!" & set /p "=!e:~-3!"<nul
        set "c=" & set /a "f=d*d/1000"
        for /l %%b in (0 3 %%a) do (
        set /a "e=(!a:~%%b,3!*d<<1)+!b:~%%b,3!+f","f=e/1000","e%%=1000"
        set "e=  !e!" & set "c=!c!!e:~-3!"
        )
        set /a "e=(d*d)%%1000" & set "e=  !e!" & set "b=000!e:~-3!!c!"
        set "e=  !d!" & set "a=!e:~-3!!a!"
)
echo. & pause & exit /b
复制代码

flashercs

这是牛顿迭代法吗?

flashercs

bug是有的,比如计算87的平方根,精确到小数点后1000位,不到100位就出错了.

523066680

山的那边海的那边有一群小升初的学生已经在用 JAVA PHP JS做网站写算法，做麻省理工的数学题，
每天 RNN，DNN，KNN， A*， 神经网络，深度学习，区块链

楼主还是可以再加强一个。

523066680

牛顿迭代法参考：http://www.matrix67.com/blog/archives/361
在支持浮点数加减乘除的环境下，牛顿迭代法比一般方案要高效得多，仅仅是线性地迭代就可以增加精确度。

这种出现多个反复goto，变量命名使用极限缩写的批处理可读性实在不好，所以我估计论坛也没有那么多闲人去充当“人肉解释器”。
在轻度阅读后的一些无关痒痛的关于可读性的建议（如果是想让别人阅读自己的代码并提出建议，而不是单纯的发布作品的话）

:next
    cls
    if "%number%"=="" goto start
    set /a temp=%number%+0
    if not "%temp%"=="%number%" goto error_a
    if not %number% geq 0 goto error_b
    if %number% geq 2147483647 goto error_c
    goto then
复制代码

这个 :next 代码块是用来获取被开方数的，不妨命名为  :GetNum 或者 :get_number

:then
    cls
    echo.&echo 请输入精确位数,然后按回车键：
    echo （指精确到小数点后第几位）
    echo （该程序不会对最后一位进行四舍五入）
    echo （精确位数最高为238609294，超出范围，会计算出错）
    echo （对于结果为整数的，程序会舍去小数部分）
    set bit=
    set /p "bit="
    goto other
复制代码

:then 代码块是用来输入精度的，不妨命名为 :set_precision （找谷歌翻译的）

这样在 ther :error_a(b/c/d/e) 中的 goto then/next 变成 goto get_number/set_precision，就很清楚是要重新获取输入。（谁还记着 then 和 next 是干什么的？）
而 :other 可以叫做 :check_precision

以及 StringLenth 按理说应该叫 StringLength

代码中还有各种  temp  nun num tga tgb tgc tgd 变量名到处“穿越”，可否改成具体含义的名称（可以谷歌翻译呀）？

523066680

回复 9# SQYSQYSQY

    我已经在修改和调整，改好再放出来。给标签和变量一个好的名称并不会占用多少空间，而可读性和可维护性会大大提高。
贴前面提到的一小部分

:start     echo.&echo 请输入被开方数（仅限整数）,然后按回车键：     echo （被开方数最高为2147483646，超出范围，会计算出错）     set number=     set /p "number="     goto get_number :get_number     cls     if "%number%"=="" goto start     set /a temp=%number%+0     if not "%temp%"=="%number%" goto error_a     if not %number% geq 0 goto error_b     if %number% geq 2147483647 goto error_c     goto set_precision :set_precision     cls     echo.&echo 请输入精确位数,然后按回车键：     echo （指精确到小数点后第几位）     echo （该程序不会对最后一位进行四舍五入）     echo （精确位数最高为238609294，超出范围，会计算出错）     echo （对于结果为整数的，程序会舍去小数部分）     set bit=     set /p "bit="     goto chk_precision :chk_precision     cls     if "%bit%"=="" goto then     set /a temp=%bit%+0     if not "%bit%"=="%temp%" goto error_d     if not %bit% geq 0 goto error_d     if %bit% geq 238609295 goto error_e     set start=yes     goto main

保存文件的代码中 多个echo 可以用括号合并，使代码更简洁

:save_and_exit     if "%bit%"=="0" (         set info=（保留整数）     ) else (         set info=（精确到小数点后第%bit%位）     )     cd /d "%UserProfile%\desktop"     set fname="%number%的平方根的结果%info%.txt"     rem 若存在同名文件，获取权限     if exist %fname% takeown %fname%         >%fname% (         echo %number%的平方根的结果：         echo %info%：         echo （未对其结果进行四舍五入）：         echo %nun%     )     goto exit

一个很明显的问题：当程序达到“大规模”、存在上亿变量运算的时候，
别的语言多么省事省心，可以分为多个模块，可以写类，不需要各种goto往返，结构清晰，为什么还要用批处理呢？
其他语言可以多线程，并行，甚至可以利用显卡（CUDA OpenCL）计算单元实现高效并行，而批处理…… 只是你编程路上的一个节点。

试想一下这种动图如果用批处理去计算每个像素点，要耗时多久。
独显+Shader，1920*1080分辨率，每个像素的计算存在数百上千次迭代，每秒可以达到30帧：1920*1080像素*100次循环*30帧

（有关这个图像可以参考 http://www.matrix67.com/blog/archives/292 可以只做了解，高中后就会学到相关知识。）

扯远了，退一步说，不管用什么语言，清晰的函数命名、变量命名、模块化才有利于构建更大的程序。否则可能源码还未达到1MB就写不下去了。

523066680

:kfmain 的轻度简化
这些常量列表可以创建到一个叫 :init 的函数中，只在开始的时候初始化一次，不会有什么开销。

:kfmain
    set /a u+=1
    rem 设置常量映射表
    set ER_2m=1
    set ER_5m=2
    set ER_4m=3
    set ER_2l=4
    set   U_1=5
    set ER_7m=6
    set ER_5l=7
    set ER_9m=8
    set ER_7l=9
    
    if defined ER_%er% (
        set %kfmain%=!ER_%er%!
        goto bignum_mp
    )
    
    if defined U_%u% (
        set %kfmain%=!U_%u%!
        goto bignum_mp
    )
    
    if "%er%"=="1m" set temp=0
    if "%er%"=="1l" set temp=1
    if "%er%"=="3m" set temp=2
    if "%er%"=="3l" set temp=3
    if "%er%"=="4l" set temp=4
    if "%er%"=="6m" set temp=5
    if "%er%"=="6l" set temp=6
    if "%er%"=="8m" set temp=7
    if "%er%"=="8l" set temp=8
    if "%er%"=="9l" set temp=9
    goto :eof
复制代码

因为末尾的值是序列递增的，在创建列表的时候甚至可以用for，进一步缩减代码（同上面理由一样，放在初始化函数中不会有什么效率影响），但是不建议这么做因为可读性超差

:kfmain
    set /a u+=1
    rem 设置常量映射表
    set /a iter = 1
    for %%a in ( E_2m E_5m E_4m E_2l U_1 E_7m E_5l E_9m E_7l ) do (
        set /a %%a=iter, iter+=1
    )
    set /a iter = 0
    for %%a in ( 1m 1l 3m 3l 4l 6m 6l 8m 8l 9l ) do (
        set /a T_%%a=iter, iter+=1
    )
    
    if defined E_%er% (
        set /a %kfmain% = E_%er%
        goto bignum_mp
    )
    
    if defined U_%u% (
        set /a %kfmain% = U_%u%
        goto bignum_mp
    )

    if defined T_%er% set /a temp=T_%er%
    goto :eof
复制代码

um...  bignum_mp 就是 bignum multiply 的意思

523066680

计算字符串长度，这里有个超完整的合集
[代码合集] [更新]求字符串长度，简短高效的批处理代码（多种算法）
（里面有我08年的老贴链接，以前真是语无伦次。）

因为楼主的被开根数受到批处理最大整数限制（10位以内），所以这个方法很好用
http://www.bathome.net/redirect.php?goto=findpost&ptid=1249&pid=26990

@echo off
set test_num=314159
set temp_str=%test_num%fedcba9876543210
set /a len=0x%temp_str:~15,1%
echo %len%
复制代码

523066680

回复 14# SQYSQYSQY

    在处理字符串的时候如果出现 & 或者 ()^ 都有可能造成字符串的某一部分被当作代码执行。
特别是提取的时候，那些裸的控制符号容易造成“攻击”。（不过我已经举不出具体的例子了，很久没用过批处理）
还有一些查表法掺入特殊字符作为标记，如果我在测试字符串也加入这些特殊字符，就会造成混淆。

打算另外写一个粗略的实现（不管细节），搞完这波再也不碰批处理了，不划算。

有一个优化方向：
假设当前的进展是：精确到了8个有效数字，m 约等于 a*a，a包含8位有效数字
假设是88888888，这个数的平方是已经知道了的
迭代到下一位数字b的时候，假设b是6，那么就需要计算 (88888888*10+6)^2 。
这个公式展开  (a*10+b)^2
= a^2*100 + 2*a*b + b^2
a^2 是上一步已经知道的,*100 直接后面加两个0，
2*a*b 比大数乘法简单，是大数*单个数*2，
b^2可以直接set/a得到

523066680

初步实现。支持大数（整数）开根，小数精确到80位耗时30秒。每个函数各自独立，没有跨函数穿越的 goto。

:init 初始化常量模板（用于计算字符串长度）
:get_int_of_root 获取根的整数部分
:get_dec_of_root 获取根的小数部分
:bignum_mp 大数乘法
:bignum_plus 加法
:bignum_minus 减法
:bignum_div_single 除法（除以单个数字）
:cmp %str1% %str2% %vname% 大数比较，返回值为 -1, 0, 1 之一
:time_used %time_a% %time_b% 粗略计算秒钟消耗

整数部分的开根用大范围二分搜索，例如判断整数根是5位数 min=10000 max=99999 mid=(min+max)/2 三个变量迭代（实际用bignum系列函数计算，消耗还挺大）
浮点数的部分用了上一楼提到的方法，已知某一层结果 a^2 = square (≈ num)
精确到下一位数字的时候可以省去部分的计算，%a%%b% ^ 2 相当于 (a*10+b)^2
展开后 = a^2*100 + 2*(a*10)*b + b^2，
其中 a^2*100 可以直接用 %square%00 表示，
当a达到一定长度的时候，这些建立在之前基础上的计算，比两个相同长度的大数相乘要快得多。

:: Bignum(integer) Square Root
:: 523066680/vicyang
:: 2018-12

@echo off
setlocal enabledelayedexpansion
:init
    rem template for counting string length
    set mod=
    set /a maxlen=2000, half=maxlen/2
    for /l %%a in (1,1,%half%) do set mod=!mod!##
    set time_a=%time%

set num=123456787654322
rem set num=10
call :get_int_of_root %num% int_root cmp
if %cmp% equ 0 (
    set root=%int_root%
    echo num = %num%, root = !root!, !cmp!
    exit /b
)

set precision=80
call :check_first %num% %precision%
call :get_dec_of_root %num% %int_root% %precision% dec_root
call :time_used %time_a% %time%
exit /b

:check_first
    perl -Mbignum=p,-%2 -le "print sqrt(%1)" 2>nul
    goto :eof

:get_dec_of_root
    setlocal
    set num=%1
    set int_root=%2
    set precision=%3
    set root=%int_root%
    rem Show int_root first
    set /p inp="%int_root%."<nul
    call :bignum_mp %root% %root% prev_pow

    set /a dec_len=0
    :decroot_lp
    set /a min=0, max=10, mid=(max+min)/2, quit = 0, dec_len+=1
    :decroot_bin_search
        rem calc [a*10]^2 + 2*[a*10]*b + b^2, part1 part2 part3
        set /a sum = 0
        set part1=%prev_pow%00
        set /a part3 = mid * mid
        set /a double_mid = mid * 2
        call :bignum_mp %root%0 %double_mid% part2
        call :bignum_plus %part1% %part2% sum
        call :bignum_plus %sum% %part3% sum

        rem compare
        call :cmp %sum% %num%00 cmp
        rem echo %root%%mid% %sum% %num%00 min:%min% max:%max% %cmp% 
        set /a range=max-min
        if %cmp% gtr 0 ( set /a max=mid )
        if %cmp% lss 0 ( set /a min=mid )
        if %cmp% equ 0 ( set /a quit=1 )
        if %range% leq 1 ( set /a quit=1 )
        set /a mid=(max+min)/2
    if %quit% equ 0 goto :decroot_bin_search

    set prev_pow=%sum%
    set root=%root%%mid%
    set num=%num%00
    set /p inp="%mid%"<nul
    if %dec_len% lss %precision% goto :decroot_lp
    echo,
    endlocal
    goto :eof

:get_int_of_root
    rem get the integer part of root
    setlocal
    set num=%1
    call :length %num% len
    rem initial min and max number
    set /a min = 1, max = 10, root_len = len / 2 + len %% 2
    for /l %%n in (2,1,%root_len%) do (set min=!min!0& set max=!max!9)
    call :bignum_plus %min% %max% sum
    rem middle_number = sum / 2
    call :bignum_div_single %sum% 2 mid
    
    set /a quit = 0
    :binary_search
        call :bignum_mp %mid% %mid% product
        call :cmp %product% %num% cmp
        call :bignum_minus %max% %min% range

        if !cmp! equ 0 (
            set /a quit = 1, cmp=0
        ) else (
            if !cmp! gtr 0 (
                set max=!mid!
                set cmp=1
            )   
            if !cmp! lss 0 ( 
                set min=!mid!
                set cmp=-1
            )
            call :bignum_plus !max! !min! sum
            call :bignum_div_single !sum! 2 mid
            rem Using !var!, because we are inside the brackets
        )
        if %range% leq 1 (set quit=1)
    if %quit% == 0 goto :binary_search
    endlocal &set %2=%mid%& set %3=%cmp%
    goto :eof

:bignum_mp
    setlocal
    set num_a=%1
    set num_b=%2
    call :length %num_a% len_a
    call :length %num_b% len_b
    for /l %%b in ( 1, 1, %len_b% ) do ( set ele_b=!ele_b! !num_b:~-%%b,1! )
    for /l %%a in ( 1, 1, %len_a% ) do ( set ele_a=!ele_a! !num_a:~-%%a,1! )
    rem for /l %%a in (0, 1, %attemplen%) do set buff[%%a]=0
    set /a id = 0, sid = 0, maxid = 0
    for %%b in ( %ele_b% ) do (
        set /a sid = id, id += 1
        for %%a in ( %ele_a% ) do (
            set /a buff[!sid!] += %%a * %%b, sid += 1, maxid = sid
        )
    )
    rem Merge
    set /a id = 0
    for /l %%c in ( 0, 1, %maxid% ) do (
        set /a next = %%c+1
        set /a buff[!next!] += buff[%%c]/10, buff[%%c] = buff[%%c] %% 10
    )

    if "!buff[%maxid%]!" == "0" set /a maxid-=1
    set product=
    for /l %%n in (%maxid%, -1, 0) do set product=!product!!buff[%%n]!
    endlocal &set %3=%product%
    goto :eof

:bignum_plus
    setlocal
    set num_a=%1
    set num_b=%2
    call :length %num_a% len_a
    call :length %num_b% len_b
    set /a max = len_a
    if %len_b% gtr %len_a% (set /a max=len_b, len_b=len_a&set num_a=%num_b%&set num_b=%num_a%)

    for /l %%n in ( 1, 1, %max% ) do (
        if %%n leq %len_b% (
            set /a buff[%%n] = !num_a:~-%%n,1! + !num_b:~-%%n,1!
        ) else (
            set buff[%%n]=!num_a:~-%%n,1!
        )
    )

    set /a id = 0
    for /l %%c in ( 0, 1, %max% ) do (
        set /a next = %%c+1
        set /a buff[!next!] += buff[%%c]/10, buff[%%c] = buff[%%c] %% 10
    )

    if "!buff[%next%]!" gtr "0" set /a max+=1
    set sum=
    for /l %%a in (%max%, -1, 1) do set sum=!sum!!buff[%%a]!
    endlocal &set %3=%sum%
    goto :eof

:bignum_minus
    setlocal
    set num_a=%1
    set num_b=%2
    call :length %num_a% len_a
    call :length %num_b% len_b
    set /a max = len_a
    if %len_b% gtr %len_a% (set /a max=len_b, len_b=len_a&set num_a=%num_b%&set num_b=%num_a%)

    set /a minus = 0
    for /l %%n in ( 1, 1, %max% ) do (
        if %%n leq %len_b% (
            set /a dt = !num_a:~-%%n,1! - !num_b:~-%%n,1! - minus
        ) else (
            set /a dt = !num_a:~-%%n,1! - minus
        )
        if !dt! lss 0 (
            set /a buff[%%n] = dt + 10, minus=1
        ) else (
            set /a buff[%%n] = dt, minus=0
        )
    )

    set delta=#
    for /l %%a in (%max%, -1, 1) do set delta=!delta:#0=#!!buff[%%a]!
    endlocal &set %3=%delta:#=%
    goto :eof

:bignum_div_single
    setlocal
    set num_a=%1
    set num_b=%2
    call :length %num_a% len_a
    set /a max = len_a, mod = 0
    for /l %%n in ( %len_a%, -1, 1 ) do (
        set /a e = !num_a:~-%%n,1! + mod*10
        set /a buff[%%n] = e/num_b, mod = e %% num_b
    )
    if !buff[%max%]! == 0 (set /a max-=1)

    set quotaint=
    for /l %%a in (%max%, -1, 1) do set quotaint=!quotaint!!buff[%%a]!
    endlocal &set %3=%quotaint%
    goto :eof

:length %str% %vname%
    setlocal
    set test=%~1_%mod%
    set test=!test:~0,%maxlen%!
    set test=%test:*_=%
    set /a len=maxlen-(%test:#=1+%1)
    endlocal &set %2=%len%
    goto :eof

:cmp %str1% %str2% %vname%
    setlocal
    call :length %1 len_a
    call :length %2 len_b
    if %len_a% gtr %len_b% (endlocal &set %3=1&goto :eof)
    if %len_a% lss %len_b% (endlocal &set %3=-1&goto :eof)
    set str1=%1
    set str2=%2
    if %len_a% equ %len_b% (
        for /l %%n in (0, 1, %len_a%) do (
            if "!str1:~%%n,1!" gtr "!str2:~%%n,1!" (endlocal &set %3=1&goto :eof)
            if "!str1:~%%n,1!" lss "!str2:~%%n,1!" (endlocal &set %3=-1&goto :eof)
        )
        endlocal &set %3=0
    )
    goto :eof

:time_used %time_a% %time_b%
    rem only for few seconds, not consider minutes
    setlocal
    set ta=%1& set tb=%2
    rem insert 1 befeore 00.00 if first num is zero
    set ta=1%ta:~-5%
    set tb=1%tb:~-5%
    set /a dt = %tb:.=% - %ta:.=%
    set dt=%dt:-=%
    set dt=0000%dt%
    set dt=%dt:~-4%
    echo time used: %dt:~0,2%.%dt:~2,2%s
    endlocal
    goto :eof
复制代码

523066680

古人云：思而不学则die （die - 通 "殆"）
于是我查了 wikipedia ，发现更快的方法，用程序实现起来，比牛顿迭代法更好用（毕竟牛顿迭代法还要涉及大数除法而且每次迭代的精度还不太好判断）。
使用“蛋疼的批处理”粗略实现，精确到小数点后80位，16秒。而且稍微改动就可以支持浮点数开根。



https://en.wikipedia.org/wiki/Methods_of_computing_square_roots

523066680

回复 19# SQYSQYSQY

就是你这程序有点bug，计算1099511627776的平方根，为啥不一会就退出了

还有我看了半天也不明白你的精确位数在那设置的，每次算到80位就退出了

1. 搜索exit语句，在两处exit /b前面加pause来防止直接退出，不是很难想到吧？
2. 既然已经知道精度是80，完全可以 Ctrl+F 搜索一下 80 定位变量位置



两处 exit 和 80 已经在图中标出

补充：
1. 图中所用的编辑器是Sublime Text 3，可以直接显示运行结果，还能显示运行时间，因此没有加pause。
    这编辑器需要安装插件来支持GBK编码，所以没写中文注释，顺便用翻译软件学一些英语。
2. 我的英语也不好，中学水平
3. 我所知道的代码的BUG是 time_used 函数计算的时间差有问题，不过不打算改了。

523066680

回复 21# SQYSQYSQY

精确到小数点后的是一位一位的。小数点之前的是一次性echo然后退出（:get_int_of_root 函数负责这一块）。
我的电脑，Win7 64位，如果是win8，win10，可能有些微差异吧。

在命令行中调用该脚本看看有没有什么错误提示。

带注释和PAUSE的版本

至于特殊字符的处理，不要浪费时间了，换一种语言，海阔天空。
也许你可以通过各种奇怪的技巧解决这些问题，但在别的语言里，这些都不是问题。
当这个语言运行效率比C低，写起来比C麻烦，写出来的代码还比C难看，为什么不直接用C？
（C可以换成ruby python golang java js lua ... ）

Perl 替换方法

use utf8;
use Encode;
my $inp='%&@^"\'?,;<>|\/:() !=';
# 反斜杠因为是剔除而不是替换，用s///处理
$inp=~s/\\//g;
$inp=~tr/%&@^"\'?,;<>|\/:() !=/abcdefghijkl÷÷[]\\mn/;
print encode('gbk', $inp);
复制代码

输出：

abcdefghijkl÷÷[]\mn

换一种玩法，把替换表放在__DATA__字段，这样我就不用手动为某些字符加反斜杠了。第一行是原始数据，第二行、第三行是替换的规则。

my $inp=<DATA>;
my ($from, $to) = <DATA>;
eval "\$inp=~tr/\Q$from\E/\Q$to\E/" or die "$!";
print $inp;

__DATA__
%&@^"'?,;<>|/:() !=\_._\,;=_;=_%_\"=\
%&@^"'?,;<>|/:() !=\_.
abcdefghijklmnopqrst +
复制代码

输出

abcdefghijklmnopqrst + this is a test

523066680

手算开根的方法，好用

在之前Wikipedia链接的 Decimal (base 10) 一节  Methods_of_computing_square_roots#Decimal_(base_10)

Find the square root of 2.
    1. 4  1  4  2
  _______________
\/ 02.00 00 00 00
   02                  1*1 <= 2 < 2*2                 x = 1
   01                    y = x*x = 1*1 = 1
   01 00               24*4 <= 100 < 25*5             x = 4
   00 96                 y = (20+x)*x = 24*4 = 96
      04 00            281*1 <= 400 < 282*2           x = 1
      02 81              y = (280+x)*x = 281*1 = 281
      01 19 00         2824*4 <= 11900 < 2825*5       x = 4
      01 12 96           y = (2820+x)*x = 2824*4 = 11296
         06 04 00      28282*2 <= 60400 < 28283*3     x = 2
                       The desired precision is achieved:
                       The square root of 2 is about 1.4142
复制代码

一开始还在想为啥用前面的结果*2作为基础 （2 28 282），一计算发现还是那个平方公式展开的结果，这个方法更进一步，又省去了一些计算量，所以速度更快。


补充一些happy886r 的作品，效率极高
批处理大数浮点乘法 - happy886r
批处理大数加法、以及2的1000次方 - happy886r
我拆了一下happy的批处理大数乘法，原来是3位数字为一段，分段计算，效率翻倍，好方法。

其他的一些
批处理怎么算超过15的阶乘？

tigerpower

回复 20# 523066680

编辑器真漂亮啊，开个新帖介绍介绍吧：）