nancygold's Journal
 
[Most Recent Entries] [Calendar View] [Friends View]

Sunday, June 2nd, 2024

    Time Event
    2:01p
    b4
    Every insane person should have one, so I made one.
    Say hi to my personal esoteric VM architecture:

    https://github.com/NancyAurum/b4

    As a side effect, it allows for cute constructions like
    <[><]>


    Still better than wasting time on anything useful for normies.

    Rejoice!

    Current Mood: accomplished
    5:16p
    Conveting integers to BCD
    As part of the b4 project, I researched if binary numbers can be efficiently converted to BCD.
    BCDs were a big thing at the dawn of computing, where everything was on perfocards, but people had to input decimals.

    In fact, they did computing directly in BCDs and invented encodings allowing for efficient subtraction.
    https://en.wikipedia.org/wiki/Excess-3#Motivation

    My own attempt resulted in using a precomputed exp10 table
    #include <stdint.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
    #include <string.h>
    
    
    uint32_t e10[] = {
    /* 0*/ 0,
    /* 1*/ 10,
    /* 2*/ 100,
    /* 3*/ 1000,
    /* 4*/ 10000,
    /* 5*/ 100000,
    /* 6*/ 1000000,
    /* 7*/ 10000000,
    /* 8*/ 100000000,
    /* 9*/ 1000000000
    };
    
    void p10(uint32_t r) {
      uint32_t q;
      int i = 9;
      for (; e10[i]>r; i--); //skip leading 0s
      for (; i; i--) {
        uint32_t e = e10[i];
        for (q = 0; r >= e; ++q) r -= e;
        putchar('0'+q);
      }
      putchar('0'+r);
      putchar('\n');
    }
    


    While looking for a smarter solution, I stumbled upon Arduino people brainstorming a divmod10 routine:
    https://forum.arduino.cc/t/divmod10-a-fast-replacement-for-10-and-10-unsigned/163586/55

    Which they use solely for printing numbers (i.e. timers for bomb detonators).

    Good compilers generating code for the targets without fast division, usually supply a custom inline routine div_by(N) for every N encounter.
    It can be made even more efficient if the input range is known.
    I think there was an algorithm for generate these div_by(N) closures.
    Akin to a perfect hash generation.
    But GCC apparently doesn't do. So much for 40 years of open source!

    Current Mood: amused
    8:10p
    Transistor level CPU emulation
    NES CPU was decapped, scanned and converted to layer maps with annotations.
    So now it is possible to simulate the real thing:
    http://visual6502.org/JSSim/index.html

    Guess it will be big when the consumer level 3d printers get good enough to print it.




    Current Mood: amused

    << Previous Day 2024/06/02
    [Calendar]
    Next Day >>

About LJ.Rossia.org