523066680

手算开根方案的初步实现，有bug待修，支持大数开根，效率没有很高，先刷新16楼那段代码的时间。
精度80位大约耗时8秒。应该可以再改，再看看吧。

:: Bignum(integer) Square Root, Decimal Solution
:: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Decimal_(base_10)
:: 523066680/vicyang
:: 2019-01

@echo off
setlocal enabledelayedexpansion
:init
    rem 创建用于计算字符串长度的模板，长度限制为 2^pow
    set "sharp=#"
    set /a pow=11, maxlen=1^<^<pow
    for /l %%a in (1,1,%pow%) do set sharp=!sharp!!sharp!

set num=2
rem set num=10
rem call :get_int_of_root %num% int_root cmp
set precision=80
rem call :check_first %num% %precision%
call :decimal_solution %num%
pause
exit /b

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

:: 手算开根方案
:decimal_solution
    setlocal
    set num=%1
    set tnum=%1
    call :length %num% len
    set /a mod=len %% 2, tlen=len, base=0
    if %mod% equ 1 (set /a skip=1) else (set /a skip=2)
    set target=!tnum:~0,%skip%!
    set tnum=!tnum:~%skip%!
    set mp_0=0

    rem prec 精度
    set /a prec = 0
    set /a tbase_len = 0, equ = 0
    :dec_loop
        set /a min=0, max=10, mid=5, range=max-min, quit=0, equ=0
        set /a tbase_len+=1
        call :length %target% target_len

        :: 预估下一个可能的数，并限制二分搜索的最大值
        :guess
        if %target_len% gtr 3 (
        if %target_len% equ %tbase_len% (
            set /a t_head = %target:~0,2%, b_head = %base:~0,2%
        ) else (
            set /a t_head = %target:~0,3%, b_head = %base:~0,2%
        )
        ) else (goto :out_of_guess)

        for /l %%a in (0,1,9) do (
            set /a t = %%a * b_head
            rem echo !t! !target:~0,2! %%a
            if !t! gtr %t_head% (
                set /a max = %%a, mid = ^(min+max^)/2
                goto :out_of_guess
            )
        )
        :out_of_guess
        rem echo, &echo %base%%mid% %target% %tbase_len% %target_len% max: %max%

        :dec_bin_search
            :: mp = [base*10+mid] * mid
            if "%base%" == "0" (
                set /a tbase = mid
            ) else (
                set tbase=!base!!mid!
            )
            set ta=%time%
            call :bignum_mp %tbase% %mid% %tbase_len% 1 mp mp_len
            set mp_%mid%=%mp%
            set mplen_%mid%=%mp_len%
            rem call :cmp %mp% %target% %mp_len% %target_len% cmp

            :: 比较 - 判断是否超出
            :cmp_begin
            if %mp_len% gtr %target_len% (set /a cmp=1&goto :cmp_end)
            if %mp_len% lss %target_len% (set /a cmp=-1&goto :cmp_end)
            :: 如果长度相同，直接按字符串对比
            if "%mp%" gtr "%target%" (set /a cmp=1&goto :cmp_end)
            if "%mp%" lss "%target%" (set /a cmp=-1&goto :cmp_end)
            if "%mp%" equ "%target%" (set /a cmp=0&goto :cmp_end)
            :cmp_end

            rem call :time_delta %ta% %time% bs_tu
            if %cmp% equ 0 (set /a quit=1, equ=1)
            if %cmp% equ 1 (set /a max=mid )
            if %cmp% equ -1 (set /a min=mid )
            if %range% leq 1 ( set /a quit=1 )
            set /a mid=(max+min)/2, range=max-mid
        if %quit% == 0 goto :dec_bin_search
        
        set ta=%time%
        set /p inp="%mid%"<nul
        rem echo, &echo tnum %tnum%, cmp %cmp%, equ %equ%, tg %target%
        if "%tnum%" == "" (
            if %cmp% == 0 (
                goto :dec_loop_out
            ) else (
                rem current precision
                if %prec% equ 0 set /p inp="."<nul
                set /a prec+=1
            )
        )

        rem echo b=%base% tb=%tbase% tg=%target% mp=%mp% mid=%mid%
        call :bignum_minus %target% !mp_%mid%! target
        if %skip% geq %len% (
            set target=%target%00
        ) else (
            if "%target%" == "0" (
                set target=!tnum:~0,2!
            ) else (
                set target=!target!!tnum:~0,2!
            )
            set tnum=!tnum:~2!
            set /a skip+=2
        )

        rem base=base*10+mid*2
        if "%base%" == "0" (
            set /a base=mid*2
        ) else (
            set /a db_mid=mid*2
            call :bignum_plus !base!0 !db_mid! base
        )

        rem call :time_delta %ta% %time% else_tu
    if %prec% leq %precision% (goto :dec_loop)
    :dec_loop_out

    endlocal
    goto :eof

::大数乘法
:bignum_mp
    setlocal
    set num_a=%1
    set num_b=%2
    set /a len_a=%3, len_b=%4
    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! )
    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 %5=%product%&set /a %6=%maxid%+1
    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

::字符串长度计算
:length %str% %vname%
    setlocal
    set test=%~1_%sharp%
    set test=!test:~0,%maxlen%!
    set test=%test:*_=%
    set /a len=maxlen-(%test:#=1+%1)
    endlocal &set %2=%len%
    goto :eof

:: plp626的时间差函数 时间跨度在1分钟内可调用之；用于测试一般bat运行时间
:time_delta <beginTimeVar> <endTimeVar> <retVar> // code by plp626
    setlocal
    set ta=%1&set tb=%2
    set /a "c=1!tb:~-5,2!!tb:~-2!-1!ta:~-5,2!!ta:~-2!,c+=-6000*(c>>31)"
    if defined %3 set /a c+=!%3!
    endlocal&set %3=%c%
    goto:eof
复制代码

523066680

回复 35# SQYSQYSQY

    当我看了 happy886r 的乘法，已经知道划分为N位一段而非逐位的处理可以令速度翻倍。参考23楼 http://bbs.bathome.net/redirect. ... 1557&pid=216162
我当然也知道 for 比 goto 快， goto 比 call 快，但我是不会让我的代码变成这样的。

不过这是批处理，如果我不花时间继续优化，我就可以做别的有趣的事情了。

523066680

回复 24# 小程936

    你是说Pi吗，很多大牛为此做过大的量工作。
传奇人物 Fabrice Ballard
有史以来最优秀的程序员有哪些？ - absfree的回答 - 知乎

523066680

nothing

523066680

优化一波，没你的快。100位5.6秒，300位35秒 （CPU比较好，换一台机可能是8秒和45秒）
仍然使用逐位的计算，未使用连续N位数字为一段的处理方案，省心。

解决的问题：之前的代码对100开根会出现 10.0000000，现在不会了。
优化的部分：去掉了很多临时数组的操作特别是 buff[] 和与之对应的for循环

:: Bignum(integer) Square Root, Decimal Solution
:: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Decimal_(base_10)
:: 523066680/vicyang
:: 2019-01

@echo off
setlocal enabledelayedexpansion
:init
    rem 创建用于计算字符串长度的模板，长度限制为 2^pow
    set "sharp=#"
    set /a pow=11, maxlen=1^<^<pow
    for /l %%a in (1,1,%pow%) do set sharp=!sharp!!sharp!

set precision=80
set num=2
call :check_one %num%
pause
exit /b

:: 独立测试
:check_one
    set ta=!time!
    rem call :check_first %1 !precision!
    call :decimal_solution %1
    call :time_delta !ta! !time! tu
    echo time used: !tu!
    goto :eof

:: 批量测试
:check_all
    for /l %%a in (1,1,99) do (
        echo test number: %%a
        call :check_first %%a !precision!
        call :decimal_solution %%a
        echo,
    )
    goto :eof

:: 使用其他工具校验/对比结果
:check_first
    perl -Mbignum=p,-%2 -le "print sqrt(%1)" 2>nul
    goto :eof

:: 手算开根方案
:decimal_solution
    setlocal
    set num=%1
    set tnum=%1
    call :length %num% len
    set /a mod=len %% 2, tlen=len, base=0
    if %mod% equ 1 (set /a skip=1) else (set /a skip=2)
    set target=!tnum:~0,%skip%!
    set tnum=!tnum:~%skip%!
    set /a mp_0=0, mplen_0=1

    set /a bstimes=0
    rem prec 当前精度
    set /a prec = 0
    set /a base_len=0, equ=0, target_len=skip
    :dec_loop
        set /a min=0, max=10, mid=5, range=max-min, quit=0, equ=0
        set /a tbase_len=base_len+1

        :: 评估二分搜索的最大值
        :guess
        if %target_len% gtr 3 (
        if %target_len% equ %tbase_len% (
            set /a t_head = %target:~0,2%, b_head = %base:~0,2%
        ) else (
            set /a t_head = %target:~0,3%, b_head = %base:~0,2%
        )
        ) else (goto :out_of_guess)

        for /l %%a in (0,1,9) do (
            set /a t = %%a * b_head
            if !t! gtr %t_head% (
                set /a max = %%a
                goto :out_of_guess
            )
        )
        :out_of_guess

        :: 做大致的除法预估 mid 值
        :estimate
        if %target_len% gtr 5 (
            if %target_len% geq %tbase_len% (
                set /a est=!target:~0,6!/!base:~0,5!
                rem echo est - !est!
                set /a mid=!est:~0,1!
                rem echo,&echo %base% !target! !est! !mid! !target:~0,5!/!base:~0,5!
            )
        )

        :: 如果预估max等于1，说明结果只能为0，跳过 bin_search
        if %max% equ 1 (set /a mid=0& goto :out_bin_search )
        rem echo, &echo %base%%mid% %target% %tbase_len% %target_len% max: %max%

        set ta=%time%
        :dec_bin_search
            set /a bstimes+=1
            :: mp = [base*10+mid] * mid
            if "%base%" == "0" (
                set /a tbase = mid
            ) else (
                set tbase=!base!!mid!
            )

            call :bignum_mp_single %tbase% %mid% %tbase_len% 1 mp mp_len
            set mp_%mid%=%mp%
            set mplen_%mid%=%mp_len%

            :: 比较 - 判断是否超出
            :cmp_begin
            if %mp_len% gtr %target_len% (set /a cmp=1&goto :cmp_end)
            if %mp_len% lss %target_len% (set /a cmp=-1&goto :cmp_end)
            :: 如果长度相同，直接按字符串对比
            if "%mp%" gtr "%target%" (set /a cmp=1&goto :cmp_end)
            if "%mp%" lss "%target%" (set /a cmp=-1&goto :cmp_end)
            if "%mp%" equ "%target%" (set /a cmp=0&goto :cmp_end)
            :cmp_end

            rem call :time_delta %ta% %time% bs_tu
            if %cmp% equ 0 (set /a quit=1, equ=1)
            if %cmp% equ 1 (set /a max=mid)
            if %cmp% equ -1 (set /a min=mid)
            if %range% leq 1 ( set /a quit=1 )
            set /a mid=(max+min)/2, range=max-mid
        if %quit% == 0 goto :dec_bin_search
        :out_bin_search 

        rem echo, &echo est: %est%, act mid: %mid%

        set /p inp="%mid%"<nul
        if "%tnum%" == "" (
            :: 如果target只剩下 00，方案结束
            if "%target%" == "00" ( goto :dec_loop_out )
            if %cmp% == 0 (
                goto :dec_loop_out
            ) else (
                :: 当前精度
                if %prec% equ 0 set /p inp="."<nul
                set /a prec+=1
            )
        )

        rem echo b=%base% tb=%tbase% tg=%target% mp=%mp% mid=%mid%
        set ta=%time%
        call :bignum_minus %target% !mp_%mid%! %target_len% !mplen_%mid%! target target_len

        if %skip% geq %len% (
            set target=%target%00
        ) else (
            if "%target%" == "0" (
                set target=!tnum:~0,2!
            ) else (
                set target=!target!!tnum:~0,2!
            )
            set tnum=!tnum:~2!
            set /a skip+=2
        )
        set /a target_len+=2

        rem base=base*10+mid*2
        if "%base%" == "0" (
            set /a base=mid*2
            if !base! geq 10 (set /a base_len=2) else (set /a base_len=1)
        ) else (
            set /a db_mid=mid*2
            if !db_mid! geq 10 (set /a dbmidlen=2) else (set /a dbmidlen=1)
            call :bignum_plus !base!0 !db_mid! !base_len!+1 !dbmidlen! base base_len
        )

    if %prec% leq %precision% (goto :dec_loop)
    :dec_loop_out
    echo,
    echo search times: %bstimes%
    endlocal
    goto :eof

:: 大数 乘以 单位数
:bignum_mp_single
    setlocal
    set num_a=%1
    set num_b=%2
    set /a pool = 0, maxid = %3
    set "res="
    for /l %%a in ( 1, 1, %maxid% ) do (
        set /a mp = !num_a:~-%%a,1! * num_b + pool, t = mp %% 10, pool = mp / 10
        set res=!t!!res!
    )

    if %pool% neq 0 (
        set /a maxid+=1
        set res=!pool!!res!
    )
    endlocal&set %5=%res%&set %6=%maxid%
    goto :eof

::大数加法
:bignum_plus
    setlocal
    set num_a=%1
    set num_b=%2
    set /a len_a=%3, len_b=%4
    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 pool=0
    set res=
    for /l %%n in ( 1, 1, %max% ) do (
        if %%n leq %len_b% (
            set /a t = !num_a:~-%%n,1! + !num_b:~-%%n,1! + pool
        ) else (
            set /a t = !num_a:~-%%n,1! + pool
        )
        set /a mod = t %% 10, pool = t / 10
        set res=!mod!!res!
    )
    if %pool% gtr 0 (set /a max+=1 &set res=1%res%)
    endlocal &set %5=%res%&set %6=%max%
    goto :eof

::大数减法
:bignum_minus
    setlocal
    set num_a=%1
    set num_b=%2
    set /a len_a=%3, len_b=%4
    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
    set "res="
    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 t = dt + 10, minus=1
        ) else (
            set /a t = dt, minus=0
        )
        set res=!t!!res!
        if !t! equ 0 (set /a zero+=1) else (set /a zero=0)
    )
    set res=!res:~%zero%!
    endlocal &set %5=%res%&set /a %6=%max%-%zero%
    goto :eof

::字符串长度计算
:length %str% %vname%
    setlocal
    set test=%~1_%sharp%
    set test=!test:~0,%maxlen%!
    set test=%test:*_=%
    set /a len=maxlen-(%test:#=1+%1)
    endlocal &set %2=%len%
    goto :eof

:: plp626的时间差函数 时间跨度在1分钟内可调用之；用于测试一般bat运行时间
:time_delta <beginTimeVar> <endTimeVar> <retVar> // code by plp626
    setlocal
    set ta=%1&set tb=%2
    set /a "c=1!tb:~-5,2!!tb:~-2!-1!ta:~-5,2!!ta:~-2!,c+=-6000*(c>>31)"
    if defined %3 set /a c+=!%3!
    endlocal&set %3=%c%
    goto:eof
复制代码

523066680

回复 30# SQYSQYSQY

优化效率一时爽，添加功能火葬场。（就目前来说浮点数开根还没搞进去，也没有经过大量的数值测试BUG）
观点：功能完善前写给人看，方便调整，完善后再优化给机器看。

发现自己代码优化后有问题，29 26 开根会出现5.99999，29楼已经纠正，顺便提速，estimate 模块用于提前估值减少二分搜索次数。
在我的主机 80位 3.5s 300位 32s，手算法似乎不怎么需要二分，可以快速判定下一位数，绕了很大的弯路，修改中。

523066680

改好了，去掉了二分搜索，5位以内的情况下粗暴遍历。
通过0到100的数字开根测试，支持大数字。在这个基础上再去优化会舒服很多，但还是要做出浮点数开根以后再说。

CPU: i7 4GHz
SQRT 2 精度 80 耗时约 2.3s。精度 300，耗时约 20s

:: Bignum(integer) Square Root, Decimal Solution
:: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Decimal_(base_10)
:: 523066680/vicyang
:: 2019-01

@echo off
setlocal enabledelayedexpansion
:init
    rem 创建用于计算字符串长度的模板，长度限制为 2^pow
    set "sharp=#"
    set "serial=9876543210"
    set /a pow=11, maxlen=1^<^<pow
    for /l %%a in (1,1,%pow%) do set sharp=!sharp!!sharp!

set precision=80
rem call :check_one 2
call :check_all
pause
exit /b

:: 独立测试
:check_one
    set ta=!time!
    rem call :check_first %1 !precision!
    call :decimal_solution %1
    call :time_delta !ta! !time! tu
    echo time used: !tu!
    goto :eof

:: 批量测试
:check_all
    for /l %%a in (1,1,99) do (
        echo test number: %%a
        rem call :check_first %%a !precision!
        call :decimal_solution %%a
        echo,
    )
    goto :eof

:: 使用其他工具校验/对比结果
:check_first
    perl -Mbignum=p,-%2 -le "print sqrt(%1)" 2>nul
    goto :eof

:: 手算开根方案
:decimal_solution
    setlocal
    set num=%1
    set tnum=%1
    :: 计算长度，判断需要截取的目标长度（1 or 2）
    call :length %num% len
    set /a mod=len %% 2, skip = 2 - mod
    set target=!tnum:~0,%skip%!
    set tnum=!tnum:~%skip%!
    set "base="

    :: prec 当前精度
    set /a prec = 0, base_len=0, target_len=skip

    :dec_loop
        :: 推算下一个数
        :estimate
            :: 如果目标值 小于 基数，下一个数字判定为0
            call :cmp %target% %base%0 %target_len% %base_len%+1 cmp
            if !cmp! equ -1 (
                set /a mid=0, mp=0, mplen=0
                goto :out_estimate
            )

            if %base_len% gtr 5 (
                set /a est=!target:~0,6!/!base:~0,5!
            ) else (
                :: 在set/a计算范围内的，[粗暴]遍历
                for /l %%a in (0,1,10) do (
                    set /a mp=%base%%%a*%%a
                    if !mp! gtr !target! (set /a est=%%a-1 &goto :out_est_for)
                )
            )
            :out_est_for

            :: 199999996400/1999999988 = 99.9999988
            :: but 199999/19999 = 10
            if %est% geq 10 (
                set /a tbase_len=base_len+1
                if !target_len! gtr !tbase_len! (set /a est=9)
            )

            set /a mid=!est:~0,1!
            call :bignum_mp_single !base!!mid! !mid! !base_len!+1 1 mp mplen
            call :cmp !mp! !target! !mplen! !target_len! cmp
            :: 如果mp超出目标范围
            if !cmp! equ 1 (
                set /a mid-=1
                call :bignum_mp_single !base!!mid! !mid! !base_len!+1 1 mp mplen
            )
        :out_estimate

        set /p inp="%mid%"<nul
        rem echo,&echo tg !target!, mp !mp!, base !base!, mid !mid!, est !est!
        if "%tnum%" == "" (
            :: 如果target只剩下 00，方案结束
            if "%target%" == "00" ( goto :dec_loop_out )
            if %cmp% == 0 ( goto :dec_loop_out )
        )

        :: 计算下一段target的值
        call :bignum_minus %target% %mp% %target_len% %mplen% target target_len

        :: 扩充target，如果被开根数已经截取完，直接补0，精度+1
        if %skip% geq %len% (
            set target=%target%00
            set /a prec+=1
            if !prec! equ 1 set /p inp="."<nul
        ) else (
            if "%target%" == "0" (set target=!tnum:~0,2!
                          ) else (set target=!target!!tnum:~0,2!)
            set tnum=!tnum:~2!
            set /a skip+=2
        )
        set /a target_len+=2

        :: 更新基数 - base
        rem base=base*10+mid*2
        if "%base%" == "0" (
            set /a base=mid*2, base_len=1+base/10
        ) else (
            set /a db_mid=mid*2, dbmidlen=1+db_mid/10
            call :bignum_plus !base!0 !db_mid! !base_len!+1 !dbmidlen! base base_len
        )

    if %prec% leq %precision% (goto :dec_loop)
    :dec_loop_out
    echo,
    endlocal
    goto :eof

:: 比较
:cmp
    set /a La=%3, Lb=%4
    if %La% gtr %Lb% (set /a %5=1&goto :eof)
    if %La% lss %Lb% (set /a %5=-1&goto :eof)
    :: 如果长度相同，直接按字符串对比
    if "%1" gtr "%2" (set /a %5=1&goto :eof)
    if "%1" lss "%2" (set /a %5=-1&goto :eof)
    if "%1" equ "%2" (set /a %5=0&goto :eof)

:: 大数 乘以 单位数
:bignum_mp_single
    setlocal
    set num_a=%1
    set num_b=%2
    set /a pool = 0, maxid = %3
    set "res="
    for /l %%a in ( 1, 1, %maxid% ) do (
        set /a mp = !num_a:~-%%a,1! * num_b + pool, t = mp %% 10, pool = mp / 10
        set res=!t!!res!
    )

    if %pool% neq 0 (
        set /a maxid+=1
        set res=!pool!!res!
    )
    endlocal&set %5=%res%&set %6=%maxid%
    goto :eof

::大数加法
:bignum_plus
    setlocal
    set num_a=%1
    set num_b=%2
    set /a len_a=%3, len_b=%4
    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 pool=0
    set res=
    for /l %%n in ( 1, 1, %max% ) do (
        if %%n leq %len_b% (
            set /a t = !num_a:~-%%n,1! + !num_b:~-%%n,1! + pool
        ) else (
            set /a t = !num_a:~-%%n,1! + pool
        )
        set /a mod = t %% 10, pool = t / 10
        set res=!mod!!res!
    )
    if %pool% gtr 0 (set /a max+=1 &set res=1%res%)
    endlocal &set %5=%res%&set %6=%max%
    goto :eof

::大数减法
:bignum_minus
    setlocal
    set num_a=%1
    set num_b=%2
    set /a len_a=%3, len_b=%4
    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
    set "res="
    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 t = dt + 10, minus=1
        ) else (
            set /a t = dt, minus=0
        )
        set res=!t!!res!
        if !t! equ 0 (set /a zero+=1) else (set /a zero=0)
    )
    set res=!res:~%zero%!
    endlocal &set %5=%res%&set /a %6=%max%-%zero%
    goto :eof

::字符串长度计算
:length %str% %vname%
    setlocal
    set test=%~1_%sharp%
    set test=!test:~0,%maxlen%!
    set test=%test:*_=%
    set /a len=maxlen-(%test:#=1+%1)
    endlocal &set %2=%len%
    goto :eof

:: plp626的时间差函数 时间跨度在1分钟内可调用之；用于测试一般bat运行时间
:time_delta <beginTimeVar> <endTimeVar> <retVar> // code by plp626
    setlocal
    set ta=%1&set tb=%2
    set /a "c=1!tb:~-5,2!!tb:~-2!-1!ta:~-5,2!!ta:~-2!,c+=-6000*(c>>31)"
    if defined %3 set /a c+=!%3!
    endlocal&set %3=%c%
    goto:eof
复制代码

523066680

回复 33# SQYSQYSQY

是的哟，if 在某些情况下会进行字符串对比。bbbbbbbbbbbbbbb gtr aaaaaaaaaaaaaaa 是成立的，换成数字，只要长度相同就会得到对的结果

42行是我用来校验结果是否正确的，调用 Perl 显示对应的开根结果。要正确执行需要安装 Perl 环境。
http://strawberryperl.com/releases.html 这玩意儿好像都不自带环境配置，装完还要自己把perl.exe执行路径添加到PATH中

对应的校验语句是临时注释掉的：
rem call :check_first %1 !precision!

523066680

回复 35# SQYSQYSQY

    查阅 ASCII 字符表，如果想学习更多关于字符编码，建议：学习 python，用python去读写各种网页文件。
关键词：Encode, Decode, Unicode, UTF8, UTF16, GBK, CP936

用其他语言显示数字符号对应的ASCII码。

>perl -e "grep {printf qq('%d' - %d\n), $_, ord($_) } (0..9)"
'0' - 48
'1' - 49
'2' - 50
'3' - 51
'4' - 52
'5' - 53
'6' - 54
'7' - 55
'8' - 56
'9' - 57
复制代码

523066680

回复 38# SQYSQYSQY

非常短（难道是受到了27楼小朋友的刺激？他短任他短，清风拂山冈。他横任他横，明月照大江）。可能有小细节需要完善：
1.414找不到操作数。
999999999999999999

    不打算先把大数和浮点数做进去再精简吗。

浮点数版本，效率老样子，代码不打算优化了，要也用Perl，或者换C艹

523066680

回复 40# SQYSQYSQY

      你这起跑线多好，我那会儿没零钱，严重的时候一周只有1元上一个小时网吧，要做点什么得在稿纸上写好，不然刷的一小时没了。

空间换时间/时间换空间
查表就是为了"空间换时间"，几百个上千元素的数组查询都会慢的也就是批处理了，不如趁早换用自由度高的语言。

那个例子可以用函数表达，x^2，和 5*x 赛跑，一开始 5*x 比较快，后来 x^2 …… 这俩太陡了，应该有更合适的曲线，暂时先这样


浮点数版本补充在39楼。

523066680

1月17日
补充 —— 是楼层穿越问题。此信息PASS

523066680

回复 37# SQYSQYSQY

      关于自由度，我不说数独，你用批处理做一做猜数字游戏的搜索树就知道了，但凡跟递归、多重镶嵌数据结构有关的东西，用批处理都不划算。
http://bbs.bathome.net/thread-49436-1-2.html
（非杠，我就是觉得你学其他语言，起跑线就会有一个质的飞跃。也不推荐Perl，现在的主流推荐就是Python，Java，C）

百度百科的描述
https://baike.baidu.com/item/%E7 ... 97/83200?fr=aladdin

举一个简单的例子：
我要生成50个随机字符，内容可以是数字和小写字母；将字符串拆割重组、输出显示整个数组：

use Modern::Perl;
# 生成 50 个随机字符，范围是数字和小写字母
my @arr = map { ('0'..'9', 'a'..'z')[rand(36)] } (1 .. 50 );
my $s = "bathomenet";
say join(",", @arr);
say join(",", split //, $s);
print length($s);
复制代码

输出

j,x,c,z,7,k,u,p,d,w,u,k,d,0,s,9,l,a,7,n,i,9,h,s,l,5,1,q,d,m,j,i,p,m,3,x,4,h,s,d,r,s,3,q,w,i,d,z,f,y
b,a,t,h,o,m,e,n,e,t
10
复制代码

这些在 python ruby perl 里面都是常规操作，字符串长度允许范围几乎就是对应内存的剩余空间。

批处理可以做到，但是会很烦，vbs同样烦，js、Powershell应该好写

回复 39# SQYSQYSQY

      我也是业余的，工作和IT不相关。可以预见的是你的路线可以是 x^2。
而我这种职业不相关的，路线基本就只能是平缓直线甚至是上下波动了

523066680

回复 40# SQYSQYSQY

    先写一个测试模块，发布前测试过会比较妥。更新后的代码测试26，37，50，65，82不通过。更新前测试通过（精确到80位）。

for /l %%a in (1,1, 100%或者其他数字%) do ( call :开根函数 )
exit/b

:开根函数
setlocal
endlocal& goto :eof
复制代码

523066680

回复 28# search_Sudoku

    将手算法原样撸了一个C++初始版本，未优化，1W精度（含输出）0.9秒。

返回来看gmp库的说明，这理论好深（估计happy能看懂，我只能看看概述）
Introduction
The current asymptotically fastest known method to compute the square-root of a n-word number is using Fast Fourier Transform (FFT) multiplication and Newton'smethod,
with a complexity of 5M(n)' [1, p. 155].2 The algorithm presented here is basedon Burnikel-Ziegler Karatsuba division [2].
这里面用到 快速傅里叶变换乘法、牛顿迭代法，以及 Burnikel-Ziegler Karatsuba 除法。

牛顿迭代法的精度增长很快（差不多翻倍增长），需要用到大数除法。实践起来，具体的精度不太好确定，因此迭代到一定次数后，除法的精度取舍也是个问题，
我也发现引用了牛顿迭代法的方案大多是给出一个预判的精度，
比如 gmp 中设置 mpf_set_default_prec (10000);  开根后 gmp_printf ("Square root: %.10000Ff\n\n", sq_out);
实际有效数字只有3068位，末尾由大量的0填充。

几种接口效率对比(i7 8核 4GHz)
Perl bignum 模块，1W精度 耗时4.5s
Python Decimal 模块，10W精度 耗时 1.0s
C++ 使用 GMP库，100W有效精度，含输出，1.5秒；不含输出，0.2秒
                           1000W位有效精度，不含输出， 2.5秒。

libgmp太凶悍

C++ 测试GMP速度以及判断有效精度的代码：

#include <iostream>
#include <sstream>
#include <iomanip>
#include <chrono>
#include "gmpxx.h"
#include "gmp.h"

using namespace std;
int main(int argc, char *argv[] ) 
{
    ostringstream os;
    mpf_class n(2, 10), r(1, 3600000);
    auto start = chrono::system_clock::now();

        r = sqrt(n);
        os << setprecision(10000000) << r;

    auto end = chrono::system_clock::now();
    chrono::duration<double> diff = end-start;
    cout << "Actual length of r: " << os.str().length() << endl;
    cout << "Time Used: " << setprecision(3) << diff.count() << " s" << endl;
    return 0;
}
复制代码

Actual length of r: 1083710
Time Used: 0.561 s （这里包含 os << r 产生的时间）

GNU MP 库中用到的算法和理论，完整版：
《Modern Computer Arithmetic》
http://maths.anu.edu.au/~brent/pd/mca-cup-0.5.9.pdf