Task: Isqrt (integer square root) of X


C++: #include <iomanip>
#include <iostream>
#include <sstream>
#include <boost/multiprecision/cpp_int.hpp>

using big_int = boost::multiprecision::cpp_int;

template <typename integer>
integer isqrt(integer x) {
    integer q = 1;
    while (q <= x)
        q <<= 2;
    integer r = 0;
    while (q > 1) {
        q >>= 2;
        integer t = x - r - q;
        r >>= 1;
        if (t >= 0) {
            x = t;
            r += q;
        }
    }
    return r;
}

std::string commatize(const big_int& n) {
    std::ostringstream out;
    out << n;
    std::string str(out.str());
    std::string result;
    size_t digits = str.size();
    result.reserve(4 * digits/3);
    for (size_t i = 0; i < digits; ++i) {
        if (i > 0 && i % 3 == digits % 3)
            result += ',';
        result += str[i];
    }
    return result;
}

int main() {
    std::cout << "Integer square root for numbers 0 to 65:\n";
    for (int n = 0; n <= 65; ++n)
        std::cout << isqrt(n) << ' ';
    std::cout << "\n\n";

    std::cout << "Integer square roots of odd powers of 7 from 1 to 73:\n";
    const int power_width = 83, isqrt_width = 42;
    std::cout << " n |"
        << std::setw(power_width) << "7 ^ n" << " |"
        << std::setw(isqrt_width) << "isqrt(7 ^ n)"
        << '\n';
    std::cout << std::string(6 + power_width + isqrt_width, '-') << '\n';
    big_int p = 7;
    for (int n = 1; n <= 73; n += 2, p *= 49) {
        std::cout << std::setw(2) << n << " |"
            << std::setw(power_width) << commatize(p) << " |"
            << std::setw(isqrt_width) << commatize(isqrt(p))
            << '\n';
    }
    return 0;
}








COBOL:        IDENTIFICATION DIVISION.
       PROGRAM-ID. I-SQRT.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 QUAD-RET-VARS.
          03 X          PIC 9(18).
          03 Q          PIC 9(18).
          03 Z          PIC 9(18).
          03 T          PIC S9(18).
          03 R          PIC 9(18).

       01 TO-65-VARS.
          03 ISQRT-N    PIC 99.
          03 DISP-LN    PIC X(22) VALUE SPACES.
          03 DISP-FMT   PIC Z9.
          03 PTR        PIC 99 VALUE 1.

       01 BIG-SQRT-VARS.
          03 POW-7      PIC 9(18) VALUE 7.
          03 POW-N      PIC 99 VALUE 1.
          03 POW-N-OUT  PIC Z9.
          03 POW-7-OUT  PIC Z(10).

       PROCEDURE DIVISION.
       BEGIN.
           PERFORM SQRTS-TO-65.
           PERFORM BIG-SQRTS.
           STOP RUN.

       SQRTS-TO-65.
           PERFORM DISP-SMALL-SQRT
           VARYING ISQRT-N FROM 0 BY 1
           UNTIL ISQRT-N IS GREATER THAN 65.

       DISP-SMALL-SQRT.
           MOVE ISQRT-N TO X.
           PERFORM ISQRT.
           MOVE R TO DISP-FMT.
           STRING DISP-FMT DELIMITED BY SIZE INTO DISP-LN 
           WITH POINTER PTR.
           IF PTR IS GREATER THAN 22, 
               DISPLAY DISP-LN, 
               MOVE 1 TO PTR.

       BIG-SQRTS.
           PERFORM BIG-SQRT 10 TIMES.
 
       BIG-SQRT.
           MOVE POW-7 TO X.
           PERFORM ISQRT.
           MOVE POW-N TO POW-N-OUT. 
           MOVE R TO POW-7-OUT. 
           DISPLAY "ISQRT(7^" POW-N-OUT ") = " POW-7-OUT.
           ADD 2 TO POW-N.
           MULTIPLY 49 BY POW-7.

       ISQRT.
           MOVE 1 TO Q.
           PERFORM MUL-Q-BY-4 UNTIL Q IS GREATER THAN X.
           MOVE X TO Z.
           MOVE ZERO TO R.
           PERFORM ISQRT-STEP UNTIL Q IS NOT GREATER THAN 1. 

       MUL-Q-BY-4.
           MULTIPLY 4 BY Q.

       ISQRT-STEP.
           DIVIDE 4 INTO Q.
           COMPUTE T = Z - R - Q.
           DIVIDE 2 INTO R.
           IF T IS NOT LESS THAN ZERO,
               MOVE T TO Z,
               ADD Q TO R.