Task: Isqrt (integer square root) of X



C#: using System;
using static System.Console;
using BI = System.Numerics.BigInteger;
 
class Program {
 
    static BI isqrt(BI x) { BI q = 1, r = 0, t; while (q <= x) q <<= 2; while (q > 1) {
        q >>= 2; t = x - r - q; r >>= 1; if (t >= 0) { x = t; r += q; } } return r; }
 
    static void Main() { const int max = 73, smax = 65;
        int power_width = ((BI.Pow(7, max).ToString().Length / 3) << 2) + 3,
            isqrt_width = (power_width + 1) >> 1;
        WriteLine("Integer square root for numbers 0 to {0}:", smax);
        for (int n = 0; n <= smax; ++n) Write("{0} ", 
            (n / 10).ToString().Replace("0", " ")); WriteLine();
        for (int n = 0; n <= smax; ++n) Write("{0} ", n % 10); WriteLine();
        WriteLine(new String('-', (smax << 1) + 1));
        for (int n = 0; n <= smax; ++n) Write("{0} ", isqrt(n));
        WriteLine("\n\nInteger square roots of odd powers of 7 from 1 to {0}:", max);
        string s = string.Format("[0,2] |[1,{0}:n0] |[2,{1}:n0]",
            power_width, isqrt_width).Replace("[", "{").Replace("]", "}");
        WriteLine(s, "n", "7 ^ n", "isqrt(7 ^ n)");
        WriteLine(new String('-', power_width + isqrt_width + 6));
        BI p = 7; for (int n = 1; n <= max; n += 2, p *= 49)
            WriteLine (s, n, p, isqrt(p)); }
}







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.