Multiplying two large numbers whose digits you have in a string, in AEC compiled to WebAssembly

Question

You can see it live here: https://flatassembler.github.io/multiplying-strings-aec.html

Function get_length_of_the_first_number() Which Returns Integer32 Is External;
Function get_digit_of_the_first_number_at(Integer32 index) Which Returns Character Is External;
Function get_length_of_the_second_number() Which Returns Integer32 Is External;
Function get_digit_of_the_second_number_at(Integer32 index) Which Returns Character Is External;
Function putc(Character char) Which Returns Nothing Is External;
Function logString(PointerToCharacter string) Which Returns Nothing Is External;

Character matrix[100*100];
Function f(Integer16 i, Integer16 j) Which Returns Integer32 Does
    Return i * 100 + j;
EndFunction

Character result[100];

Function get_length_of_the_result() Which Returns Integer16 Does
    Integer16 i := 0;
    While i < 100 Loop
        If result[i]=0 Then
            Return i;
        EndIf
        i += 1;
    EndWhile
    Return i;
EndFunction

Function prepend_a_character_to_the_result(Character char) Which Returns Nothing Does
    Integer16 i := get_length_of_the_result() + 1;
    While i > 0 Loop
        result[i]:=result[i - 1];
        i -= 1;
    EndWhile
    result[0] := char;
EndFunction

Function multiply() Which Returns Nothing Does
    // Initializing the matrix...
    Integer32 i := 0, j := 0;
    While i < get_length_of_the_second_number() Loop
        j := 0;
        While j < get_length_of_the_first_number() + get_length_of_the_second_number() + 1 Loop
            matrix[f(i,j)] := ' ';
            j += 1;
        EndWhile
        i += 1;
    EndWhile
    logString("The matrix is successfully filled with spaces.");

    //Filling up the matrix...
    Integer32 pointer_to_the_digit_in_the_second_number := 0;
    While pointer_to_the_digit_in_the_second_number < get_length_of_the_second_number() Loop
        Integer16 carry := 0,
            pointer_to_the_matrix_column := get_length_of_the_first_number() +
                pointer_to_the_digit_in_the_second_number + 1;
        Integer16 pointer_to_the_digit_in_the_first_number := get_length_of_the_first_number() - 1;
        While pointer_to_the_digit_in_the_first_number >= 0 Loop
            Integer16 product :=
                (get_digit_of_the_first_number_at(pointer_to_the_digit_in_the_first_number) - '0') *
                (get_digit_of_the_second_number_at(pointer_to_the_digit_in_the_second_number) - '0') +
                carry;
            matrix[f(pointer_to_the_digit_in_the_second_number, pointer_to_the_matrix_column)]
                := mod(product, 10) + '0';
            If product >= 10 Then
                carry := product / 10;
            Else
                carry := 0;
            EndIf
            pointer_to_the_matrix_column -= 1;
            pointer_to_the_digit_in_the_first_number -= 1;
        EndWhile
        If carry Then
            matrix[f(pointer_to_the_digit_in_the_second_number,pointer_to_the_matrix_column)] :=
                mod(carry, 10) + '0';
        EndIf
        If carry >= 10 Then
            pointer_to_the_matrix_column -= 1;
            matrix[f(pointer_to_the_digit_in_the_second_number, pointer_to_the_matrix_column)] := 
                carry / 10 + '0';
        EndIf
        pointer_to_the_digit_in_the_second_number += 1;
    EndWhile
    logString("The matrix is now filled with the products of the first number and the digits of the second.");
    
    //Summing up the matrix...
    result[0]:=0;
    Integer16 carry := 0;
    i := get_length_of_the_first_number() + get_length_of_the_second_number();
    While i >= 0 Loop
        Integer32 sum := carry;
        j := 0;
        While j < get_length_of_the_second_number() Loop
            If not(matrix[f(j, i)] = ' ') Then
                sum += matrix[f(j, i)] - '0';
            EndIf
            j += 1;
        EndWhile
        prepend_a_character_to_the_result(mod(sum, 10) + '0');
        carry := sum / 10;
        i -= 1;
    EndWhile
    If carry Then
        prepend_a_character_to_the_result(carry + '0');
    EndIf
    logString("The matrix is now summed up and the product of the two numbers is calculated.");

    //Replace the trailing zeros with spaces. Now that's a lot easier to do in AEC than in JavaScript...
    i := 0;
    While result[i] = '0' Loop
        result[i] := ' ';
        i += 1;
    EndWhile
    logString("The trailing zeros in the result are now replaced by spaces.");

    //Print the result...
    putc(' ');
    putc(' ');
    i := 0;
    While i < get_length_of_the_first_number() Loop
        putc(get_digit_of_the_first_number_at(i));
        i += 1;
    EndWhile
    putc('*');
    i := 0;
    While i < get_length_of_the_second_number() Loop
        putc(get_digit_of_the_second_number_at(i));
        i += 1;
    EndWhile
    putc('\n');
    
    i := 0;
    While i < get_length_of_the_first_number() + get_length_of_the_second_number() + 1 + 2 Loop
        putc('-');
        i += 1;
    EndWhile
    putc('\n');

    i := 0;
    While i < get_length_of_the_second_number() Loop
        j := 0;
        While j < get_length_of_the_first_number() + get_length_of_the_second_number() + 1 Loop
            putc(matrix[f(i,j)]);
            j += 1;
        EndWhile
        putc('\n');
        i += 1;
    EndWhile
    
    i := 0;
    While i < get_length_of_the_first_number() + get_length_of_the_second_number() + 1 Loop
        putc('-');
        i += 1;
    EndWhile
    putc('\n');

    i := 0;
    While result[i] Loop
        putc(result[i]);
        i += 1;
    EndWhile
    putc('\n');

    logString("The result should be visible on the screen now!");
EndFunction

Answer 1

//Replace the trailing zeros with spaces. Now that's a lot easier to do in AEC than in JavaScript...
i := 0;
While result[i] = '0' Loop
    result[i] := ' ';
    i += 1;
EndWhile

If the result is zero, this doesn't leave a single zero, the entire number is gone. You can compensate for that later too.

If product >= 10 Then
    carry := product / 10;
Else
    carry := 0;
EndIf

carry := product / 10; is enough, you don't need the other case, the carry will be naturally zero anyway.

Character matrix[100*100];

If you add a partial product to the result while forming it, you don't need to store partial products temporarily before adding them. Not having to deal with that matrix could simplify the code in several places.

Regarding prepend_a_character_to_the_result, prepending characters in this way is awkward, I suggest doing something to avoid it. For example:

• Building the result at the end of the array, printing the result "from the middle" (wherever the leading digit ends up).
• Building the result from the least significant digit up, printing it in reverse.

---

If you want to be fancy, you can merge a small chunk of adjacent digits into one, eg take 4 digits to form a number between 0 and 9999 (inclusive range) and do the multiplication in base 10000 (I chose 10000 because the product still fits in a 32-bit integer, and the conversion back to decimal is simple unlike a power-of-two base). Reducing the number of "digits" by a factor of about 4 that way reduces the number of multiplications by a factor of about 16x. A lot more algorithmic trickery is possible but that may not quite fit this question, I'd be happy to add it if you want.