Binary as a Human Base

[floral plover]

these two pass (plus every number from zero to three hex two)

(the test is running correctly, if I change the answer to be wrong it realizes it)

@fallow sundial

pub fn generate_binary_name(i: usize) -> String {
    fn gen(x: usize) -> String {
        if x == 0 { return String::new(); }
        else if x == 1 { return "one".into(); }

        let terms = [
            "two", "four", "hex", "byte", "short", "int", "long", "overlong", "byteplex"
        ];

        let n = find_n(x);
        let middle_term = terms[n];
        let left = x >> 2usize.pow(n as u32);
        let right = x % 2usize.pow(2_u32.pow(n as u32));

        let mut first_term = gen(left);
        let last_term = gen(right);

        surpress_redunant_one(&mut first_term);

        format!("{first_term} {middle_term} {last_term}")
    }

    if i == 0 { return "zero".to_string(); }
    else if i == 1 { return "one".to_string(); }

    let mut r = gen(i);
    r = r.replace("two one", "three");
    r = r.replace("  ", " ");
    r = r.trim().to_string();
    r
}

fn surpress_redunant_one(s: &mut String) {
    if s.len() < 3 { return; }

    if &s[0..3] == "one" {
        *s = s[3..].to_string()
    }
}

fn find_n(x: usize) -> usize {
    use std::f64::consts::LN_2;
    (((x as f64).ln() / LN_2).ln()/LN_2).floor() as usize
}

[fallow sundial]

yippee

this makes my code 10x worse

[floral plover]

Woo

[fallow sundial]

VecDeque time

wait no

it's so much worse

aaaaaaaaa

I'm going to have to use a arrayvec aren't I

nvm

I found a way

fn gen(x: u64, vec: &mut Vec<Term>, front: bool) {
    use Term as T;

    if x == 0 {
        vec.push(T::Zero);
        return;
    } else if x == 1 {
        if !front {
            vec.push(T::One);
        }
        return;
    }

    let n = find_n(x);
    let middle_term = [T::Two, T::Four, T::Hex, T::Byte, T::Short, T::Int, T::Long][n as usize];
    gen(x >> 2_u64.pow(n as u32), vec, true);
    vec.push(middle_term);
    gen(x % 2_u64.pow(2_u32.pow(n as u32)), vec, false)
}

just realized I don't need Zero

I can just return zero if it's a empty vec

not even that

god

if it's 0

[red parcel]

you get it

[fallow sundial]

more simple

[fallow sundial]

we can probably get rid of the floating point operations here too

well in find_n

you'd just need a match statement with the superpowers and some comparison checks

is it faster to do floating point operations or 8 ordering comparison 🤔

[stiff glade]

one l
two lı
three ll
four lıı
four one lıl
four two llı
four three lll
two four lııı
two four one lııl
two four two lılı
two four three lıll
three four llıı
three four one llıl
three four two lllı
three four three llll
hex lıııı

oh

[red parcel]

looks right to me now!

and then you can multiply by hex to get the next four digits :D

and then byte (and hex) to get the following 8

it's great

ı

oh coool

sorry just figured out how to write that character with compose key on my keyboard

[stiff glade]

cool!

i just have this ahk script i use to speak a language i'm learning

the problem is that if i'm writing lists like the one i just wrote i have to go back and forth because w -> ꝡ

[red parcel]

ah, yeah been there, but I'm on linux now

[floral plover]

:0
How?

[floral plover]

What?

[red parcel]

right_alt+i+.

for my setup at least

[fallow sundial]

to find the biggest 2^2^n you can just compare them in order with <=

[floral plover]

No I mean, I have a physical compose key
I'm asking how you added it

[red parcel]

my settings has an option to set a key for it

[floral plover]

That's what I tried in the beginning! But it was way simpler to plug the formula into a calculator and let it spit out an inverse for it

[fallow sundial]

maybe

i just don't know if it is faster

[floral plover]

Here's how I'm using mine

[floral plover]

I can benchmark it :3

[fallow sundial]

if you wanna

[red parcel]

...is that vi?

[floral plover]

I do wanna

[floral plover]

It's bat
It's my XCompose file

[fallow sundial]

it'd just be like a bunch of superpower.. in a match statement

[red parcel]

idk where to customize mine

also your shell is pretty love the blue

[floral plover]

wait hm?

[fallow sundial]

well you can't do >= in a match statement

[floral plover]

ok wait

[fallow sundial]

or actually ..superpower

[floral plover]

I don't understand how rust tests work

I have a function marked with #[test]
I have no clue how to run it

[fallow sundial]

cargo test

?

[red parcel]

and also cargo t

[floral plover]

what

i just tried that

it only ran the ones in tests/

dkjhfakshf

this one works

time for one with match

and then it's criterion time

[fallow sundial]

make sure to only include the ones that fit in a u64

[floral plover]

hm?

[fallow sundial]

well some of them aren't going to fit for the array implementation

[floral plover]

array implementation?

[fallow sundial]

the one with the floats

since it's indexing into a array

[floral plover]

i don't understand what you mean

[fallow sundial]

the original one

it has byteplex

[floral plover]

...right
hmm
should I be using u128? Does it even fit in a u128?

[fallow sundial]

I've capped mine to u64

i don't think users want it bigger then that

[floral plover]

that sounds right

how are you capping it?

[fallow sundial]

just using a u64 lol

[floral plover]

...lmao

makes sense

I think u32 is good enough

u32::MAX is 4294967295

[fallow sundial]

aight

i don't think it matters too much

though it benefits the match case the most

[floral plover]

Exactly
Also helps with .pow() because it takes u32, so less conversions

[fallow sundial]

well no it benefits the while loop the most

[red parcel]

oh btw @floral plover your glyph to words test can't display over 21 bits... apparently

[fallow sundial]

if match is better then floating point then a u64 could be tried to see if it changes anything

[floral plover]

the glyph displayer?

damn it

[red parcel]

yee

[floral plover]

i was hoping i wouldn't have to look at it again

[floral plover]

it might just be that the canvas is too thin

yeah probably

you can't use methods or indexing in a match statement

that is very annoying

[fallow sundial]

you can

use consts!

[red parcel]

fn main() {
    let y = 81;
    const x: i32 = 3_i32.pow(4_u32);
    match y {
        x => println!("woah!"),
        _ => println!("boo")
    }
}

woah!

[floral plover]

wait what

[red parcel]

that is cool as heck I've been looking for that

only works for const funcs and const lookups but wowzers

[floral plover]

aw man

[red parcel]

make SUPERPOWERS[0] a constant right above the match

[floral plover]

i am i am

wait

how many superpowers do you need to fit in a u32?

[red parcel]

less than byte

but more than hex

wait uhh

[floral plover]

less than byte?

byte is u8::MAX

[red parcel]

hex gets you 8

bits

byte gets you 16

uh

[floral plover]

right, of course
it's short

[red parcel]

I guess int

[floral plover]

so up to n = 4

[floral plover]

The loop is absolutely awful

[red parcel]

can I see the loop?

[floral plover]

I sent all three at the same time, I love how loop got sent last

oh my

they're neck and neck for large n

and for small ones too

l m a o

ö

i need better inputs

i'll do 1e7 1.5e7 2e7 2.5e7 ...

Delta of about 10ps max
I think it's reasonable to say that they perform the exact same

Actually, hold on
Is the switch one even programmed correctly?

[floral plover]

( @fallow sundial )

[fallow sundial]

Black box?

[floral plover]

Does this need a black box?

[fallow sundial]

Ah

Probably not

But still having one on their inputs just in case

[floral plover]

Doesn't hurt to try

But I think my switch function is wrong

Could you double check, pretty please?

[fallow sundial]

They look fine

Check godbolt?

Maybe they just compile they similarly

I was doubting that could happen

[fallow sundial]

Couldn't you test this by just running a range other over the switch and the floaties

[floral plover]

@fallow sundial ...huh

[floral plover]

I did it for 1e7, 2e7, ... and it came out right
but the exponents get large and manual testing didn't feel perfect

[floral plover]

Blackboxing seems to have made quite the difference

[fallow sundial]

The compiler is a tricky fiddle

[floral plover]

here's the violin ones

[floral plover]

I have added many more points (43 per line), I love how absolutely consistent it is

[stiff glade]

what is this chart?

[floral plover]

Two algorithms for finding which superpower of two is needed to name a binary number: using the floats function (direct math) and the match statement (essentially about 10 comparisons)

[floral plover]

(these ones, the loop turned out to be really awful for some reason (i've probably coded it wrong or smth))

x axis is input value, y axis is nanos

[red parcel]

Iirc match is pretty much maximally efficent

Like the compiler is supoused to really rack it's optimizations to do as little work as possible, so if this can be done with nonconditional logic to pick the branch it will do so

[floral plover]

Now I'm wondering if it's close to the speeds that indexing has

How much faster would it be to get an array that's 100000000 elements long and just to index into it?

[floral plover]

I'm still in awe at how comparatively abysmal float operations are compared to a single match

[fallow sundial]

matches are fast

also

post code 🔫

I wanna decomp

godbolt

[floral plover]

I'm not at computer rn

And I did try to gold bolt but only one of the functions compiled into assembly
The other didn't make any assembly at all

I gave up very quickly after exhausting my exhaustive list of troubleshooting steps (which is a single step: make them pub)

[fallow sundial]

The other didn't make any assembly at all
what

[fallow sundial]

also that if check is really not helping

[floral plover]

It's in both functions exactly the same ¯⁠\⁠_⁠(⁠ツ⁠)⁠_⁠/⁠¯

How should I handle 0 and 1?

[fallow sundial]

i mean for the match statement you can just return them

wait no you can't

well

for godbolt and benchmarking better to just pretend they can't happen

cuz they won't in normal code

[floral plover]

I could always fuck up the code around it

[fallow sundial]

simply don't

¯_(ツ)_/¯

[floral plover]

I like it when the compiler/runtime crashes hard and goes "STOP. YOU IMBECILE AND MORON, YOU DID AN OOPS"

I'll try without the if

In a sec

[fallow sundial]

do provide a copy when you are on the pc because copying this into godbolt is painful

[red parcel]

Floats aren't known for therr speed, never even const lol

[fallow sundial]

you could try using a f32

it should be accurate enough

[floral plover]

Omg good idea

So I need to

• try with f32
• send code
• remove ifs
  (Writing down because i will forget)

[fallow sundial]

yes

[floral plover]

f32 one works!

time for benchmark

[fallow sundial]

now time for f16 /j

though I am concerned for f32

if you pass in a u32::MAX

[floral plover]

const INPUTS: [u32; 43] = [
    1000,
    5000,
    30000,
    2501000,
    5001000,
    7501000,
    10001000,
    12501000,
    15001000,
    17501000,
    20001000,
    22501000,
    25001000,
    27501000,
    30001000,
    32501000,
    35001000,
    37501000,
    40001000,
    42501000,
    45001000,
    47501000,
    50001000,
    52501000,
    55001000,
    57501000,
    60001000,
    62501000,
    65001000,
    67501000,
    70001000,
    72501000,
    75001000,
    77501000,
    80001000,
    82501000,
    85001000,
    87501000,
    90001000,
    92501000,
    95001000,
    97501000,
    100001000,
];

fn find_n_f64(x: u32) -> u32 {
    use std::f64::consts::LN_2;
    (((x as f64).ln() / LN_2).ln()/LN_2).floor() as u32
}

fn find_n_f32(x: u32) -> u32 {
    use std::f32::consts::LN_2;
    (((x as f32).ln() / LN_2).ln()/LN_2).floor() as u32
}

fn find_n_switch(x: u32) -> u32 {
    const SUPERPOWERS: [usize; 6] = [
        2_usize.pow(2_u32.pow(0)) - 1,
        2_usize.pow(2_u32.pow(1)) - 1,
        2_usize.pow(2_u32.pow(2)) - 1,
        2_usize.pow(2_u32.pow(3)) - 1,
        2_usize.pow(2_u32.pow(4)) - 1,
        2_usize.pow(2_u32.pow(5)) - 1,
    ];

    const SUPER_1: usize = SUPERPOWERS[1];
    const SUPER_2: usize = SUPERPOWERS[2];
    const SUPER_3: usize = SUPERPOWERS[3];
    const SUPER_4: usize = SUPERPOWERS[4];
    const SUPER_5: usize = SUPERPOWERS[5];

    match x as usize {
        ..=SUPER_1 => 0,
        ..=SUPER_2 => 1,
        ..=SUPER_3 => 2,
        ..=SUPER_4 => 3,
        ..=SUPER_5 => 4,
        _ => 5,
    }
}

I think that's all the code

[fallow sundial]

look at how short the switch is compared to the f32 one

it is so much more shrimple at the assembly level

[floral plover]

I like how you can see the superpowers embedded directly in it
It feels cute :3

[fallow sundial]

why are you turning it into a usize?

[floral plover]

Why is LBB1_4 just a single ret?

[fallow sundial]

idk man

[floral plover]

...very good question

remnants of old code

shouldn't alter the assembly, though, no?

[fallow sundial]

it shoudn't

[floral plover]

oh, right
i do it because the superpowers are usizes too, and they're usizes because I can't math and got worried I was missing the higher numbers

[fallow sundial]

though it means you can remove the _ => 5

so maybe it will

[floral plover]

the 5 isn't even in the assembly you sent

i think it's already done it for me

[fallow sundial]

heh

whoops forgot the - 1

[fallow sundial]

interesting

it isn't showing assembly anymore

[floral plover]

So it wasn't me being dumb

phew

anyway graph!

[fallow sundial]

you needed a #[inline(never)]

it seems rust wants to optmize this hard

[floral plover]

it optimizes it so hard it doesn't exist

[fallow sundial]

yes

[floral plover]

how even

[fallow sundial]

since it's a basic match statement it can do magic ig

[floral plover]

This took like 20 minutes of benchmarking

[fallow sundial]

so it just doesn't compile anything because it knows it can do a better job later

[fallow sundial]

very nice improvement

also u64 output is a bit more complex then just the u32 one

u32

[floral plover]

wild

[fallow sundial]

there is fucking shr and xors in there for god knows reasons

[floral plover]

it's incredible how unable i am to read assembly

[fallow sundial]

I can't do it either I just guess

[floral plover]

the singular dot is indexing
it's so close

full image

[fallow sundial]

Yummy

What about with a u64?

[floral plover]

I should remove the number of datapoints
This is getting to, like, 40 minutes of benching (made up number but it feels long)

[fallow sundial]

Good idea

It's O(1) anyways

[floral plover]

The data looks so pretty though 😭
I wish I both had a GPU and could run this on a GPU

[floral plover]

u64, where?

in the switch?

[fallow sundial]

Yee

[floral plover]

uhhh

i don't see what you mean

[fallow sundial]

I mean for like both

The return and the input

[fallow sundial]

Like here

[floral plover]

so, like this?

[floral plover]

perfect perfect

[floral plover]

@fallow sundial

[fallow sundial]

certainly noticeable

but not so bad

u128 is probably way worse

[floral plover]

Not sure what happened to the floats

sigh
*adds*

[fallow sundial]

mhuaha

[floral plover]

any other ideas before i leave this running and go to bed? /gen

[fallow sundial]

apart from doing the floats with u64/u128, no

[fallow sundial]

yum

waity

[floral plover]

oh?

[fallow sundial]

you need more superpowers don't you

[floral plover]

i didn't change the test inputs

[fallow sundial]

either way

[floral plover]

doesn't make sense to go beyond it if some of the tests just die

My tests are

const INPUTS: [u32; 43] = [
    1000,
    5000,
    30000,
    2501000,
    5001000,
    7501000,
    10001000,
    12501000,
    15001000,
    17501000,
    20001000,
    22501000,
    25001000,
    27501000,
    30001000,
    32501000,
    35001000,
    37501000,
    40001000,
    42501000,
    45001000,
    47501000,
    50001000,
    52501000,
    55001000,
    57501000,
    60001000,
    62501000,
    65001000,
    67501000,
    70001000,
    72501000,
    75001000,
    77501000,
    80001000,
    82501000,
    85001000,
    87501000,
    90001000,
    92501000,
    95001000,
    97501000,
    100001000,
];

[fallow sundial]

but like it should be getting penalized for allowing a higher set of numbers

[floral plover]

hmm

am I still allowed to share the const amongst them?

[fallow sundial]

you'd have to cast them

[floral plover]

i should just need to add an extra arm to the match, no?

[fallow sundial]

yes

[floral plover]

sigh

I've been awake for 24h
Should I make a const for each function or share and cast?

[fallow sundial]

probably better not share

[floral plover]

i weep

[fallow sundial]

you can always use u64::MAX!

[floral plover]

hm?

[fallow sundial]

superpowers are the same as the unsigned integers MAX size

[floral plover]

https://cdn.discordapp.com/emojis/1159823183881437254.gif?size=48&name=plink~1&quality=lossless

how far does u128 go?!

[fallow sundial]

340_282_366_920_938_463_463_374_607_431_768_211_455u128

[floral plover]

oh nevermind
i'm stupid

u32 and u64 share constants, yes?

ah, no

[fallow sundial]

if you were doing the casting to a usize

but better not to

[floral plover]

this feels so incorrect for some reason

[fallow sundial]

looks fine

ig the biggest issue is that you are returning a the type number and not the index usize

[floral plover]

i'm always casting back to usize regardless

welp, time to run it

7 benchmarks
43 datapoints each
3 seconds of warm up + 5 seconds of testing each

= 40 minutes of straight benching

*barrel rolls into bed*

[fallow sundial]

huh 🤔

A u64 can never be a long

that feels weird but it's correct

[floral plover]

This is unlocking things in my brain in such a clunky manner
I love it

[floral plover]

@fallow sundial

[sly steeple]

I have done pretty much nothing but read about pure math since this. Like, I'm just peeling back my brains layers of assumptions about how math work. All because someone told me to count in base 2 lol.

[tiny plaza]

oh pure math is fun

[fallow sundial]

u128 is very punishing

[floral plover]

and yet more powerful
freaking universe with its tradeoffs >:(

[tiny plaza]

in any system optimizing for X~

[abstract latch]

I really was digging base 2 until the counting part, brain hort

I can barely keep track counting by 1s in base 10 😭

[tiny plaza]

it actually makes way too much sense once it clicks

example for this number:

llllll

if the number is one, two or three, then its name is one, two or three

if not

grab the first digit

lllll l

can you grab double that amount? if so, do it

llll ll

repeat until you can't

ll llll

in that split, put the name of that power of 2. this is 2^4 which is a hex

ll hex llll

name both sides with the same method

two hex llll
two hex ll four ll
two hex two four two

[fallow sundial]

in that split, put the name of that power of 2. this is 2^4 which is a hex

this step is confusing

[floral plover]

The video explains it graphically but really fast
I recommend watching the 10 second clip a couple times

[fallow sundial]

since you'd want it to be one power after

"what is the smallest power of 2 that can fit the number"

i guess it's not "repeat until you can't"

it's repeat until you have the whole number

because you can't double the grab for ll llll

[tiny plaza]

it's because you grabbed 4 digits

Coca ↩️

[Reply to:](#1200152161858896012 message) > in that split, put the name of that power of 2. this is 2^4 which is a hex

2^4 is called a hex

[fallow sundial]

so it's not how many times you grabbed it's what you grabbed

and repeat until you can't is repeat you reached a 0?

[tiny plaza]

repeat until you can't double grab, or until double grabbing means you grab the entire number

so here
lılı

you stop at lı lı because double grabbing means you grab the entire number

and here lııllı you stop at lı ıllı because there aren't enough digits to double grab

[fallow sundial]

pain

[tiny plaza]

ngl i quickly got good at visually doing it

[floral plover]

^^

it's so fast

[unkempt karma]

Ayo, hexadecimal binary just dropped

[floral plover]

Isn't that the same thing but with padding

[unkempt karma]

Padding?

[floral plover]

It's binary but with redundant zeros

[unkempt karma]

Hmm, well

Kinda technically redundant yeah? But like, the units make it easier to track

It's featural symbols for 0-15

[floral plover]

Why not just use the ones for 0 and 1
It's the exact same but without redundancy

[junior jackal]

little gaps, same reason it's easier to read 139,482,093,809 than 139482093809

[floral plover]

The underbars do that job, no?

And you can group in as much as your brain can handle, not limited to four

[unkempt karma]

In a vacuum yes

Mentally, you can chunk better

[floral plover]

You can chunk in any amount of grouping
Even irregular amounts

You need not restrict yourself to hex

[unkempt karma]

Sure - the same applies to large decimal numbers though, there's no strict reason to group it in chunks of 3

You could also go 1234,5678,9012

[abstract latch]

Cursed

[unkempt karma]

grouping them by 4 is a nice middle ground for my eyes

[abstract latch]

It's very cursed

I like Japanese grouping. Myriad ftw

[unkempt karma]

Sorry, I meant the binary symbols

[abstract latch]

https://en.m.wikipedia.org/wiki/Japanese_numerals

Ah

[floral plover]

We would if our naming system wasn't base three

The naming system we're settling on for binary is also binary, so grouping isn't restricted like in decimal

[unkempt karma]

I mean, you could make your binary naming system like anything

Power of two would be the most natural

[floral plover]

Yes

So we did

[unkempt karma]

But surely you'd use some larger base?

You wouldn't go

[floral plover]

No

Binary is the best base

[unkempt karma]

zero
one
onezero
oneone
onezerozero

[floral plover]

Yeah, because 2024 is two zero two four, right?

(in some languages it is but that's besides the point)

[unkempt karma]

It's two thousand, twenty four

[floral plover]

And 1010 is "two four two" in our system

[unkempt karma]

thousand and twenty being larger base placeholders

[floral plover]

What

No
They're multiples of the power of the base

Of "a" power ig

[unkempt karma]

We have unique words for
1 - 20
100
1000
1000000
1000000000

And we group them accordingly for smaller stuff

[floral plover]

And we have unique words for
0
1
10
100
10000
100000000
...

[unkempt karma]

In binary?

[floral plover]

Yes

[unkempt karma]

What are those words?

And why use increments of 2^3 specifically?

Derp, 2^2

[floral plover]

The ones proposed in The Video were good
Zero, one, two, four, eight, hex, byte, short, int, long, overlong, byteplex

[floral plover]

We name
2^2^0
2^2^1
2^2^2
...

It's most efficient

Each new word unlocks a shitton of numbers

The decimal system is kind of shit for naming ngl

It's a sort of base 11, which is cringe

Because 11 isn't 1010

[unkempt karma]

So like
0 = zero
1 = one
10 = duo
11 = duo-one
100 = quad
101 = quad-one
110 = quad-duo
111 = quad-duo-one
1000 = oct
Etc?

[floral plover]

No

Yes

2^(2^n)

Oop message is gone

[tiny plaza]

no yes my bad i said that for another reason and realized i was wrong

[floral plover]

Oh lmao
It do happen

[floral plover]

Yes, basically
We also do some simple search and replace to compact numbers a bit by reducing very common patterns

Like "two one" is changed to "three"

So 1100 is "three four"

And 11_0000 is three hex

[floral plover]

(I think I prefer the English words tbh, but that's just preference)

[unkempt karma]

Sure that's fine

[floral plover]

Oh and 1000 isn't oct

It's "two four"

[unkempt karma]

How?

[floral plover]

There's no proper name dor "two four"

[floral plover]

Wdym how

[tiny plaza]

10 four 00
two four zero
two four

[unkempt karma]

1000 = (single number) 000

[floral plover]

(Well, we could introduce 'eight', but I personally haven't)

[unkempt karma]

Oh wait hang on

two (x) four

[floral plover]

Yes

[unkempt karma]

That gets a bit weird though, because

[floral plover]

And nine is "two four one"

1001

[unkempt karma]

So take that for example

Nine is two (x) four (+) one

The operations vary according to the positions

What is this, French???

[floral plover]

Like in decimal lmao

Two thousand twenty four
Two (*) thousand (+) two (*) ten (+) four

Digits having different values is the entire foundation of using a positional number system

[tiny plaza]

yeah literally

what is this french no its the numeric system that has dominated math for centuries by now

[floral plover]

Exactly lmao

[tiny plaza]

except optimized to its maximum potential

[floral plover]

I'm confident saying it's the best one

(if there's another one, two four hex perstack ping me, I would genuinely love to learn)

Using perstack instead of percent is rattling my brain

Why is relearning elementary and deeply ingrained concepts so difficult 😔

[unkempt karma]

For this to be equivalent you'd need to introduce "two four" or whatever as an actual placeholder

one eight, two eight, three eight, four eight

Oh wait hang on, you alraedy did that with four itself smh

so we have
one
two
three
four
four one
four two
four three
two four
two four one
two four two
two four three
three four?

[floral plover]

Yep

[floral plover]

All seems right

[unkempt karma]

Ehh, just for ease of parsing, I'd like at least up to 8 to have unique numbers

[floral plover]

Having more unique numbers slows parsing down, no?

[unkempt karma]

zero
one
two
three
four
five
six
seven
eight
eight one
eight two
...
eight seven
two eight
two eight one
...
two eight seven
three eight
...
seven eight seven
eightwo

[unkempt karma]

Marginally, I guess

[floral plover]

It's not as blindingly obvious what the name is from the digits

[unkempt karma]

On the one hand yes, but from the number scheme you'd have the association of

six = II_

Or more specifically, six = ++++++

[floral plover]

What

[unkempt karma]

Sorry hang on, what the name is from the digits?

[floral plover]

So how would you name 110_0000?

[unkempt karma]

What's the missing number?

[floral plover]

It's a separator

Rust syntax, number is 1100000

Hmm
I guess if you stop at eight, that's always six hex

I think I can see it

But getting to grips with only naming three and the superpowers is better for learning, so I'm sticking with it

[unkempt karma]

Isn't it 6 hex if you stop at 16?

Which I'm all for huh

[floral plover]

What

hex is a superpower

[unkempt karma]

0110 0000

Isn't that the grouping?

[floral plover]

Hex is always named

[unkempt karma]

I like the idea of throwing hands to count

[floral plover]

Like binary finger counting? Yeah definitely, it's very neat

[unkempt karma]

If only I didn't have ring fingers

[floral plover]

FF: if you can only use up to the middle finger, you can sacrifice your thumb to gain access to the other two

So you can use 100 digits per hand

It's very useful

[unkempt karma]

Explain?

[floral plover]

So uhh

The objective is to not have to go all the way up and down with the fingers

So you can make a bar with your thumb
Finger resting on your thumb := 0
Finger kind of elevated := 1

You only need a cm of two of movement, because the binaryness only depends on contact with the thumb

[unkempt karma]

Ah

Hmm, what about palmar counting?

[tiny plaza]

i think this would be four two hex

impl Pronoun<Any> for casenc ↩️

[Reply to:](#1200152161858896012 message) So how would you name 110_0000?

[unkempt karma]

What do you call the like, flat skin on the inside of your knuckles?

Like, the fingerprint of the proximal and middle knuckles

I realized the problem with this system too late

You don't have enough pointer fingers between your thumb and other hand 😢

Better install neural LEDs on every finger patch and make them glow independently

[floral plover]

Of course, but I meant with their system of naming up to eight
I thought there might be more than one way to name a number, but I'm not sure now

[floral plover]

What

[unkempt karma]

Depends on if you actually still introduce hex, I guess

If you keep hex and eight, wouldn't that just be six hex?

[unkempt karma]

The standard idea is that you have a digit for each palmar

But I was like "have a power of 2 for each palmar"

[floral plover]

Yeah that's what I said
Which is why I'm not sure

[unkempt karma]

And once I was posting, I only then had the thought of "waaait, how will you point at them?"

[floral plover]

@amber spruce
Behold

I forgot to send the practicer i made, but it's basically finished :3

[amber spruce]

just finished the video

and damn

[red parcel]

mood

[amber spruce]

square algorithm being a breeze? I am sold

universal divisibility test? no words

and this universal disibility algorithm doubles down as the digital representation of recurring fractions?
damn again

[amber spruce]

I am still shocked how this method of the magic sequence to derive the representation of a fraction works at any number

[red parcel]

Can you explain the step that you do after the magic sequence, I keep getting lost at that point

[amber spruce]

so, you check the in between, if it is an increase (then put 0) or a decrease (then put 1)

if the sequence ends at 1, it is recurring, if it ends at 0, it is terminating

[red parcel]

That's easy af wow

[amber spruce]

and works at literally any number, thats the most mindblowing bit to me

bit, hehe

[red parcel]

Part of it feela really intuitive for that fact

Given it's modulos of powers of two and our bits are powers of two

[amber spruce]

trying to figure out how the square root algorithm goes on when the number is not a perfect square

[amber spruce]

I actually knew an algorithm to derive square roots by hand before this video, that didnt involve converting to binary in some way or another

babylonian method iirc, you consider a square with area equal the number, then divide it in tens and units, and solve some kinda straightforward area algebra to get the sides, which is the result

obviously nothing that can beat the simplicity of doing it in binary but, in there I knew how to keep going when the number wasnt a perfect square

[red parcel]

Remember that after a number there is an infinite sequence of implied zeros

So when you keep going just bring two zeros down

[amber spruce]

after the radix point

yeah that makes sense

its fun to play with it with pixels

you surely cant be more compact than that lol

[fallow sundial]

meanwhile I made mine huge because I didn't want to do anti aliasing

[amber spruce]

lmao

long ones

[fallow sundial]

discord seems to be compressing it >:#

[amber spruce]

does anyone know how to make borrowing more intuitive at a digit level in subtraction?

I more than once found myself in the situation of "hmm, 8 - 5... thats just 3", but totally lost in how to actually perform the borrow between multiple digits

[fallow sundial]

hehe

[amber spruce]

I feel in that meme of 18 - 9, borrow the 1 from 8, now you get 18 - 9

[red parcel]

I don't really bother carrying in subtraction
If i have

 .
 10000
-   10
=01110
```I just write ones rightward until a one on either number I guess?

[amber spruce]

... that makes sense

[red parcel]

1000-10 is 990 i guess

But one is also nine-ish so yeah

[amber spruce]

yeah half of the cool usability of binary comes from the fact that 1 is both the first after zero and the last digit as well xD

[red parcel]

hydrogen moment

[amber spruce]

1/(b-1) is r1, 1/(b+1) is r0Z, and in binary Z is also 1, for example

I chuckled with a comment saying "thats probably the video with most Little Fermat Theorem applications that has nothing to do with Fermat or Fermat Theorems"

so, without having a font to write with, how yall are handling writing binary without 0 and 1?

[red parcel]

I think some of them are using dotless i

But I'm mostly sticking to 101010 because keyboard

[amber spruce]

I saw vertical pipe with dots as well

|.|.

unfortunatelly its not underlineable looks like

|.|.

not sure why

[red parcel]

But then no radix point ;_;

[amber spruce]

just use a comma instead

https://tenor.com/view/big-brain-gif-27108854

[red parcel]

What abt repeating?

[amber spruce]

also a comma is more consistent with it being a line going down the baseline

[red parcel]

Fair

[amber spruce]

good question

using a standard keyboard I guess I would just throw an r like they did on the video

|.|r.|
not terrible I guess

strange, but not sure how else to go about it

[amber spruce]

trying out converting to and from quaternary spoken form

... hold up

this is on itself a convenient way to write up the binary numbers without access to a cool font

2H41 or 2x41
2x343

[amber spruce]

my mind is kinda annoyed about how you can reduce "two one" to "three" but you simply cant reduce "two four" to "eight" without creating big hiccups in usability

[red parcel]

Two four is very different from two one

[amber spruce]

took me a while to understand what is the actual logic, even though I am used to mess around with bases

[red parcel]

You can reuse three for three four though :)

Saves you from one two four lol

[amber spruce]

yep, this system is so nice

two one four actually

[red parcel]

Shit

[amber spruce]

two one four two one sounds so annoying lel

[red parcel]

1111

Hence three

Kinda like it though

Keeps the pattern simple

[amber spruce]

I guess it would be understandable to just skip the magnitude when there is no gaps in daily usage

i.e. saying "three three" instead of "three four three"

both inform you how to write the same way

probably more intuitive to do that when it isnt an amount

[red parcel]

This is intiruiging

[amber spruce]

now I am imagining spelling large chains lol

"hex hex... oh four... three oh two"
(10000 10000 000 11 0 10)

[red parcel]

Those aren't hex

[amber spruce]

actually it looks ambiguous if oh two is 0 10 or 00

[red parcel]

Hex is 10000

[amber spruce]

true

[red parcel]

Three three goes there ig

[amber spruce]

actually no... there is never a multiplier on the left of two, right?

[red parcel]

Except one.. yeah

I think this is just saying bit strings but slightly more compact tho

[amber spruce]

yeah

just thinking on that because phone numbers tbh

nobody speaks them as amounts

id numbers in general

also there is the issue of how to speak fractionary numbers

the video didnt even touch that lol

but in general its either speak the fraction itself or spell the number after the radix point

[amber spruce]

on the foot notes they mention how "perstack" sounds a feasible version of percentage on binary
not sure how intuitive it would actually be, a stack being four hex

the footnote:

[6.k] jokes aside, perstack works well as the equivalent of percentages in binary, because
many common simple fractions can be expanded to a denominator of 63, 64, or 65. [...]

[amber spruce]

a third can be expanded to 21/63 but I am not sure how to use this to reach the approximated value using "perstack"

would it just be 21 in binary recurring?

[red parcel]

Not sure but i found this pretty pattern in n×1/n

It's always really clearly 0r1

Which is basically one

[red parcel]

Err, at least for 5 and 9

[amber spruce]

I mean, matematically, nx1/n should always be 1

[red parcel]

Yeah

[amber spruce]

so this pattern should hold

[red parcel]

But i found the infinte sequences have a very nice pattern

The bits multiply out and sum really cleanly ig

They bitwise or into place, i wonder if this holds

[amber spruce]

to 3 is pretty neat as well

[red parcel]

15 works beautifully

You could prolly reverse engineer a fraction representation like this pretty easily

[amber spruce]

random observations
Four, Hexa, Byte, Short, Int, Long, Over(long), Peta(byte)

all have an unique initial letter

so you could use just 0, 1, 2, 3 and the initial letter to write binary the same way you would say them in a compact manner

Four is better as a distinct symbol than as a digit, so perhaps could even replace it by Nibble for less confusion

wait, Hexa would be the equivalent of Nibble, nvm

[amber spruce]

Got curious if there was a method to calculate logarithm that becomes easy peasy on binary

Yep there is

For a number n in base b
Divide n by the nearest power of b that is less or equal than n, the exponent is the integer part of the result
Take the result and raise it by the base (m^b)
Repeat

[floral plover]

Do you have an example, pretty please?

[amber spruce]

Gonna just copy the post

This is a method I found a year ago. This method takes a lot of time but it will give an accurate answer.
To calculate log(25):

1. Divide 25 by the nearest power of 10. The condition must be 25 ≥ 10^n.
2. The value of n is 1 because 25 ≥ 10^1. So the initial answer is 1.xxxxxx.
3. Divide 25 by 10^1. The result is 2.5.
4. Raise 2.5 by 10. So 2.5^10 ≈ 9536.7
   (Note: The number is raised to 10 because we are already looking for the digits after the decimal point.)
5. For the next values, the same process will be used.
6. Divide 9536.7 by the nearest power of 10.
7. 9536.7 ≥ 10^3 so n=3. The answer is now 1.3xxxxx.
8. 9536.7 / 10^3 = 9.5367
9. Raise 9.5367 to 10. 9.536710 = 6222733625
10. 6222733625 ≥ 10^n so n=9. The answer is now 1.39xxxx.
11. Repeat the same process until you get the desired precision.
12. So log (25) ≈ 1.39794.

Lmao of course it wasnt a single line

And discord fucked the powers...

Fixed the exponents

And apparently it is guaranteed to produce a single digit after the first step when the base of the log and the base you are writing on coincide

Cant answer why

[floral plover]

👀
That looks way easier in binary

[amber spruce]

gonna try to run a test on |..| (9)

1. divide |..| by the nearest power of |. such that |..| >= |.^n;
2. this would be n = ||, and thus the initial answer is ||.xxx
3. divide |..| by |.^||; the result is ...

I dont know if I am doing that right lol, but it looks like it is .r||...

long division still sucks in binary

anyway

forth step, raise by the base so... just a product by itself

why am I doing long division when I could use fractions

[floral plover]

I can't read binary without the sticks notation 😔

[amber spruce]

I can help that; does |..| work for you?

[floral plover]

Much more readable, surprisingly

:3

[amber spruce]

I am working on the fractions here, because I have way more trust on them than on long division

[floral plover]

Oooh binary fractions! I didn't consider they could exist for binary!

[amber spruce]

yeah and you know what? I didnt consider that it is impossible to get a recurring fraction dividing by powers of the base...

[floral plover]

Oop, true!

[amber spruce]

all done, now we can go on lol

actually I have the sharp feeling I messed something when converting fraction to radix

now for the next digit of the log we repeat

which would give us 0, since the whole part is 1

[floral plover]

Ngl I lost the process a bit

[amber spruce]

first step: find the largest power that is smaller than the number you are on

smaller or equal

or, in another words, you can just match the number of digits

the power then is your integer part

then, divide the original number by such power, and raise the result by the power (we are just squaring because yay, binary)

that math is this step

now, having the result of this squaring in hands, we repeat to get the next digit

but right now, the number being |,.|...|, the largest power is simply |

lmao a comma is way too small for that to be a good ascii notation

[amber spruce]

the exponent being 0, we now know the answer is approx. ||,. so far

dividing by 1 keep the number the same...

huh

discovered another point this algo becomes simpler in binary

we can just keep raising until it becomes larger than 1

that will be the sequence of zeroes

and when it reaches 2, it is a 1 in the approximation

yeah lb(|..|) is approx ||,.. and I will not keep going this calculation

I mean

[floral plover]

Goddamn

[unkempt karma]

The numbers lines mason

What do theh mean

[floral plover]

Numba

Issa numba

[amber spruce]

is this a meme happening in real time or I just didnt understand the question?

[unkempt karma]

Well you see, there comes a time in every orange's life where they must ask themselves

should I be doing remedial math in my late twenties???

[red parcel]

(1001/1000)^10 = (1010001/1000000) = 1.010001

1001 * 1001 = 1001 + 100100 = 1010001

(They didn't square it, they multiplied it by itself but im typing on phone)

[red parcel]

Tall is one, short is zero

[unkempt karma]

Wait hang on, I think I get it

[fallow sundial]

I mean not having them split into fours kinda defeats the purpose

[red parcel]

Idk, good for keeping it straight

Like a notebook

[fallow sundial]

on pixel art?

[red parcel]

Oooooh now i get why they were lost lol

[unkempt karma]

No wait, I don't get it

So I get that it's like long division and stuff right? But how do the steps work here

Run me through this segment

[red parcel]

I think they explain it here?
I don't know how the weird part in the last img works yet either lol

Oh

That's two things

[unkempt karma]

Oh wait hang on

Is the multiplicatoin thing a completely unrelated second thing?

Is that what's going on here?

[red parcel]

Partly unrelated

[unkempt karma]

9x9, so

[red parcel]

They use it to find the numerator of the equal fraction

They say (9/8)^2 is equal to (81/64), but i think that's just incorrect?

[unkempt karma]

is it?

(9*9)/(8*8) = 81/64, no?

[red parcel]

Yes, but that's not (9/8)^2

Is it?

Brain meltyyy

[unkempt karma]

Unless I'm veeeery brainfoggy, isn't the multiplication commutative?

[red parcel]

It is

I am incredibly dense rn lol

(9/8)^2 != 9/8 therefore i thought it was wrong

That's not solid logic though :/

[unkempt karma]

Ah fair enough

I mean, 2 out of 3 of your logic steps were correct

[red parcel]

(It's almost like division being complicated makes me bad at math or something (silly))

[unkempt karma]

(9/8)^2 != 9/8
(a/b)^2 = a/b
=> (9/8)^2 must equal 9/8
=> contradiction

(was the chain of reasoning)

[red parcel]

Yeah

Also I love how they wrote out 9^2 but not 8^2, because it's so trivial

[amber spruce]

Its easier to parse than a sequence of sticks

Without the line my mind kinda mangles them idk why, so for me at least, a single line is still better than no line

Also, I didnt have any particular reason to go for a particular group so, there is no purpose being defeat methinks

[amber spruce]

These are two operations, the two fractions above, and below I am multiplying the... numerator? Idk, anyway

The two lonely short sticks is me skipping the multiplication by 0

Then in the end I sum

[amber spruce]

Which is why I gave up on doing it and used fractions

Which then thr result is the product of the top on top of the product of the bottom

And then, since it is dividing by a power of 2, just move the radix point

[red parcel]

it just occured to me, you're way more likely to have easy divisions like this

2^n grows slower than 10^n, so you're far more likely to run into powers (assuming you're less likely to see a number as it gets larger) of two than ten, and since multiplying and dividing those becomes trivial, binary has a huge advantage

[amber spruce]

Random thing I discovered is, that spoken framework is so fucking usefuk

Like

Its way easier to determine the spoken form than converting it to decimal

nd then

The spoken form informs what is the value

Two fours two for example, you directly knows its eight plus 2, thus its 10 in decimal

Way better than sum digit by digit

[red parcel]

oh that makes sense

[amber spruce]

So if you finger count in binary, the spoken form makes very easy to work out the decimal value as well

[red parcel]

it's basically summing combinations of bits instead, so as you memorize those combo's equivilence in base-10 it gets way faster

[amber spruce]

And as the cryptic math shows at the end, it is literally the most information dense way

[red parcel]

does that work for two hex byte though? that number is a bit odder than just two four or something

[amber spruce]

Yep

two hex four = 2x16 + 4 = 32 + 4 = 36

[red parcel]

ah, your doing the multiplication in decimal then?

[amber spruce]

Funny how "4" technically is not a number, but a magnitude in this system

[amber spruce]

Yep

[red parcel]

it is a number

[amber spruce]

If keeping in binary you dont need to convert

[red parcel]

each word is both a magnitude and a number, it's brilliant

[amber spruce]

It is a number as much as hex is

[red parcel]

yes

[amber spruce]

But yeah you could say that

[red parcel]

I just think of hex as 10000

[amber spruce]

In binary or decimal?

[red parcel]

binary

in decimal it's 16

[amber spruce]

The number of 0s is off lol

Or not

Nah my vision is bad

But yeah

Its just that in english, "hundred" isnt usually parsed as a number on itself, but "one hundred" is

[red parcel]

because hundred isn't a number

it's only a magnitude

[amber spruce]

Same deal with four and hex in this system by what I understood

[red parcel]

it's as the hard-to-parse part of the video toward the end said, the exponents are binary too

it's the same

[amber spruce]

I mean, I would use hex and four as numbers in any case

[red parcel]

took me a while to understand what on earth they were on about ngl

[amber spruce]

Its just fun how four is not just a number, despite being called four

[red parcel]

yeah

also I love how the system describes numbers as equations, it's simple ones, but they also help you memorize them

[amber spruce]

I just said "its not a number" because the spoken form is quaternary, so the higher digit is 3

Thats not really different on what we do in natural languages, but in binary feels more natural to do that somehow

[red parcel]

two four being 8 or 1000 is really intutive once you learn the system, but it's also literally saying 10* 100 = 1000

[stiff glade]

"one hex" is redundant in this system, "one hundred" isn't

the correct way to say "one hex" is "hex"

[red parcel]

yeah one is only used to represent the state of the last bit of a two bit set, it's kinda annoying, but it's also the most reasonable way

[amber spruce]

I see more like "its tecnically more correct to say one hex, but its also redundant"

[red parcel]

damn mathmatical indentities saying x*1 = x lol

but I guess you have a solid point here

in my brain, there are effectively no "places" (ones place, tens place, etc etc) in this spoken system

but also it's kinda only places?

it's funky lol

which made comprehending the explaination at the end of the video damned difficult ngl

cause you had the tens place of the thousands places, the ten thousands place, but in binary, there are N places for each word, defined recursively... and you get it, but it's really cool to me lol

[amber spruce]

Yeah tbh I prefer the recursive approach than theoretically internalizing the pattern

I would get a brainmelt if the gigantic sequence on how to speak numbers was the only resource on this framework

[unkempt karma]

That just sounds like summing and multiplication

[tiny plaza]

division is so much better in binary

you can even do it without knowing what the numbers are

[amber spruce]

And..? I am confused what is the point you are making

[unkempt karma]

I'm speaking in memea

Or well, in this instance it wasn't even speaking so much as "referencing the thing that's similar to this"

[amber spruce]

lmao I searched "binary as a human base" on google directly to see if I could find any more resources to feed this hyperfocus

found a bunch of pyschological, medicinal and sociological papers about gender binary and non binary people

[floral plover]

*googling how many bits needed to count all gemders*

[zenith dagger]

Atleast 1

[red parcel]

Im gonna say the same number of bits as their are real numbers

fuck you, transcedentals your gender

[amber spruce]

in the more extreme case, and considering just humans...

the same number needed to count all humans

[red parcel]

Do there exist genders unexpressed by people?

[amber spruce]

wait does agender count as void and thus not count and multigender are counted more than once?

[amber spruce]

probably yes

also there is a considerable chunk of the queer community that just goes by "unlabeled"

gender: undefined

[red parcel]

Impl Into<Option<Gender>>

[amber spruce]

javascript makes undefined and null different because its gender lel

okay I may see myself out

[red parcel]

exactly 83886080

(twitter -> tumblr -> reddit -> pinterest -> discord, outstanding)

[floral plover]

This is the research spirit we love to see

[amber spruce]

having 8 and 12 used in spoken form is as no cost as having 3 so, why not

[floral plover]

Also stack sounds fun

[red parcel]

It does

[amber spruce]

4 hex right

I am still cooking in my mind how exactly it works using as an analogue of percentage as suggested in the footnotes

honestly, I guess its easier to just eyeball the proportion by knowing a stack is 4 hex, than try to workout a fraction number

it does sound fun to simply say "I have a stack of this stuff" lol

[red parcel]

Totally don't already say that, what kind of nerd would say that... (silly)

[amber spruce]

afaik, anyone who plays minecraft looks like

which unfortunatelly isnt me

[amber spruce]

thinking a lot about logs

you could simplify the algorithm to successive squarings up to the precision, and then moving the log of that result n decimal places

like, if you want 3 digits of precision, take the number n, square, square and square again
so... lb n = lb (((n²)²)²)/8 for example

and... taking a square of a number in binary, is almost guaranteed to double the number of digits, which just adds a 0 in the log result

so the only way for a log to have a 1, is when the squaring results in a carry in the last digit, making the length of the result the double plus 1

only then you would get a 1 in the fractional part of the log approximation

[floral plover]

https://cdn.discordapp.com/emojis/1159823183881437254.gif?size=48&name=plink~1&quality=lossless

[amber spruce]

and the only way to have it to carry in the last digit in a squaring, is if it is all ones

is it possible to, from a binary number that is not all ones, to reach a number that is all ones?

[amber spruce]

I got that wrong

it will get a carry digit if there is a sequence of zeroes smaller than a sequence of ones

like in |.||, the two occupy more space than the one zero, so it carries in the end

[floral plover]

I wonder if binary simplifies the 'resistances in parallel' operator

x • y = 1/(1/x+1/y)

(I did not follow the sqrt one at all)

[red parcel]

I can do sqrt but get lost on div ;_;

[amber spruce]

it is simple, but many steps, if you take any of them in the wrong order you mess it lol

[red parcel]

Looks like a lot of recipricals, I wouldn't bet on it being too hard, but the third would be modulo of a fraction @_@

[amber spruce]

put 1 on the result and subtract 1 of the most significant pair of digits; this is your working value
then, loop:
is the value higher or equal than the result appended 01?

• if yes, append 1 on the result and subtract the previous result with 01 appended from the working value
• otherwise, append 0 on the result
  join the next pair on the working value

[floral plover]

Modulo?

[amber spruce]

I guess the sqrt algo is annoying because it has a boilerplate

[floral plover]

gAsp

[red parcel]

Remainder from division

[floral plover]

In *this* server??

[floral plover]

But it doesn't have any, no?

[red parcel]

...I'm not sure my brain is lost gimmie a minute

it's power of two % n, so there is one, and it's awful I think?

[floral plover]

I'm confused now

[red parcel]

this is the magic sequence for 7, right?

[amber spruce]

yep

[red parcel]

oh, weird

I do not comprehend this ngl

OH

oh dear

[amber spruce]

I assume this doesnt try to do integer division with fractions

[red parcel]

1/3 goes into power of two, that power of two * three times

that's okay for us though, since the magic sequence is gonna be over 1/x+1/y, which likely won't go into 1 perfectly?

hmmm

yeah that's pretty cursed

(N is 1/15 + 1/17 here)

[floral plover]

It's usually not a whole number afaik

The result of the operation, I mean

[red parcel]

it has to be rational, if fed rational inputs at least

so I think the magic sequence can work for us here

[floral plover]

Does it work for factions?

[red parcel]

I... do not know

hmmm

[amber spruce]

thats a pretty cursed operator lel

[red parcel]

well this sequence ends, idk what that means yet though

or if it's a floating point error here @_@

[floral plover]

It's relatively common I think : shrug :

[red parcel]

literally never even heard it mentioned in passing afaik, so idk about that

[floral plover]

Does desmos use floats or fixed point?

[red parcel]

does seem like a decently useful expression though

floats, it's.. problematic

iirc at least

[floral plover]

Oof

Welp

Time to make a fixed point calculator

[amber spruce]

the other format of it is much more usable in binary

I needed a lot of brainpower to figure out it lel

[red parcel]

I think it works

[amber spruce]

so, yeah, binary makes the other format more usable than the reduced form

[red parcel]

it gets 7.75 before quiting which feels close?
though idk how to know where to put the radix point or if there is a floating point problem here making it quit early

I assume it's a floating point problem, I doubt 1/15+1/17 goes into 32 evenly

nvm it definitely doesn't

oh wait it does?

that makes sense I picked a number above and below 16, so they add to 32, and they multiply to a whole number

[tiny plaza]

massively important for anything electrical

impl Pronoun<Any> for casenc ↩️

[Reply to:](#1200152161858896012 message) It's relatively common I think : shrug :

[red parcel]

makes sense, given it's name

[tiny plaza]

ah lmao

well its not only for resistances

induction in series and capacitance in parallel too

[red parcel]

I'm guessing no, given my results, maybe if we start from a negative power of two though?

ugh

[red parcel]

can't even quite explain my steps here but this did work when I started from 2^-5

still I feel like finding the magic sequence of 0.125490196 isn't quite easy....

I wonder if it's faster to just do the division lol

[amber spruce]

I am still obsessed with logs and squaring

it has to be a better way to squaring, which would make the log algorithm more straightforward

[amber spruce]

I just realized you can divide to conquer...

|.| * |.| = |.| * (|.. + |) = |.|.. + |.| = | |..|

and squaring again

| |..| * | |..| = | |..| * (| .... + |... + |) = | |..| .... + ||.. |... + | |..| = |. .||| ...|

I may not have found a better way to squaring, but I found that I could have been doing multiplication as a whole a lot simpler

I maybe will start using little endian in my notes to make it easier to align and do math 😵‍💫

call me crazy but little endian does make things much more smoother

[floral plover]

Little endian by hand? Goddamn

[amber spruce]

so I dont lose time right-align the numbers

much much better

[amber spruce]

updates on my quest

https://www.youtube.com/watch?v=_FoONg5Meyc

found a fancy method of squaring

still watching, gonna think later of the implications of using binary with this

... yeah this method runs way faster on binary

||.
|.| -> ||.*|..+| -> ||..|
|..

||..
|.|. -> ||..*|...+|.. -> ||. .|..
|...

[red parcel]

Oh I bet this is easy in binary

Given that "easy number" could be a power of two, the multiplication becomes a bitshift operation effectively

So just find the farthest right bit, multiply by that and add the square of that power of two?

Gonna try it that sounds fun

nope I'm wrong somewhere, hmm

right I have to multiply by number with that bit added in again

I am dumb, gonna think through this again lol

[amber spruce]

Edited a little to be a lil more clear what is happening

The formatting had gone fucked on mobile

[amber spruce]

You add the square of the difference between the original and the other 2 numbers

23^2 = (23 - 3)(23 + 3) + 3^2

[hoary vector]

this was a r/programmerhumor trend like, last year but i had to

wth is |_||_| |_|_||

[floral plover]

It's a number

[amber spruce]

the representation of one, if you wanna be pedantic

[serene radish]

Gender real

[hoary vector]

          | i
male      |       female
|----------------------|
          |
          | -i

[hoary vector]

imaginary genders when

[serene radish]

Genderfluids

Using a concept of complex rotation, sexuality of a genderfluid person can be expressed as

[floral plover]

New pronoun set

[serene radish]

Complex pronoun set!

[hoary vector]

w

we have

male

female

and if/m^2 * sqrt(3) + ln(2918)

i wanna pull out tex

[amber spruce]

Pull out the texx

[amber spruce]

Yeah idk tex

[hoary vector]

me when

[hoary vector]

@amber spruce

\frac{x}{y} is x/y, \sqrt = sqrt, \ln = ln

shocking ik

[fallow sundial]

bleh

[daring vapor]

Is there a github link to the project in here?

[fallow sundial]

don't think so

[sly steeple]

Oh that would be handy

[floral plover]

I finished it and forgot it

The repo has my irl name '>.>

[floral plover]

DM me and I can send the source/binary if you want

[sly steeple]

Do you think you are going to keep updating your repo? If not would you be okay with someone else posting a public version just in case anyone finds this forum in the future?

[floral plover]

I don't plan on touching it again

It's a good idea

[sly steeple]

I can upload the repo if @daring vapor doesn't want to. How would you want to indicate your authorship of the code?

[floral plover]

I have no idea

Is there an established way of doing it?

[daring vapor]

The cargo.toml has a author field? That might work

[sly steeple]

I figured that would work, just a matter if you have a username people can look you up by that won't link you to a name or something personal.

[amber spruce]

silly bits: binary counting helping me mindlessly set up a collision function

[glossy zephyr]

Literally

[hoary vector]

computer cocde found in dna 😭

[glossy zephyr]

Wish my dna was programmable. I would add rust if going_to_procrastinate || going_to_do_any_of(BAD_HABITS) { dont(); }

To my source code

Also I would write an usb driver https://xkcd.com/644/

xkcd: Surgery

Damn. Not only did he not install it, he sutured a 'Vista-Ready' sticker onto my arm.

[junior jackal]

dont() is such a clear function name

[glossy zephyr]

And so easy to implement

[cloud kestrel]

Make it an unhygienic macro

[junior jackal]

the exclamation mark adds needed emphasis--

[daring vapor]

A summary of neuralink/j

seriously they basically made a driver that converts the signals that say "move arm" into "move mouse"
Its basically only usable for paralyzed people where the signals wont conflict with body movements

[floral plover]

sounds phenomenal when you describe it like that

[daring vapor]

Yea meanwhile everyone who heard about neurolink is going "cant wait to get ads streamed into my brain ugh!"

Its incredibly annoying how new tech is getting framed and effectively fearmongering people into killing progress on that tech

Nuerolink isnt even the first thing to do this
The biggest leaps it made were

• shrink the hardware down to be minimally invasive and minimally cumbersome to have
  Thats it. That's the big achievement.
  Making it small enough it doesn't look like they have a billion wires strapped to their head.

[floral plover]

Sounds pretty impressive

Shrinking down hardware sounds incredibly difficult

[hoary vector]

justdont();

[solemn trout]

its extremely understandable as a "this is scary" , the ads thing is most likely ironic with a grain of truth for most peope

also, depends on who is running it, and focus is on neuralink cuz musk

also, capitalism, need i say less.

[daring vapor]

Its literally incapable of sending signals to the brain.
Only receiving.
We are well over 50 years away from a usable 2 way brain/tech interface.

[solemn trout]

trve...
but recieving signals still also sparks a privacy fear, and you have to see that "ads in my brain" are just quippy lines

[red parcel]

They put ads on the main menu of my tv, no doubt they would stream them to my head if they could

But they obvs can't, it's just a great indicator of corprate greed and why I don't trust them

[glossy zephyr]

Wouldn't feel comfortable that i have propertiary software in my head, unless if eu enforced the software to be foss

[daring vapor]

Pacemakers already have proprietary stuff :/ you probably sol

[glossy zephyr]

Computers suck

[daring vapor]

Even the most low level linux people agree
You cant escape proprietary.
It exists even in the hardware micro code level and you'll never be able to replace everything.

[hoary vector]

foss pacemakers when

[unkempt karma]

Since no alternative actions were specified, this causes the janTatesa process to hang

[honest yew]

i feel like using images just overcomplicates the program

you can just output binary using commas and bars

|,|| |,,| ,,|,

discord formats it in a retarded way