log☇︎
1100+ entries in 0.483s
mod6: one thing, that i never really thought about is going the other direction; 1 * 2 * 3 ...
jhvh1: asciilifeform: 0.240 * 65536 = 15728.64
asciilifeform: !~calc 0.240 * 65536
mircea_popescu: !W (format nil "~6,2F" (factorial (* 1024 1024)))
mircea_popescu: !W (DEFUN FACTORIAL (N &OPTIONAL (ACC 1)) (IF (<= N 1) ACC (FACTORIAL (- N 1) (* ACC N))))
phf: !W (DEFUN FACTORIAL (N &OPTIONAL (ACC 1)) (IF (<= N 1) ACC (FACTORIAL (- N 1) (* ACC N))))
jhvh1: mircea_popescu: 6.023 * 10**23 * 5.3 * 10**6 * 1.6 * 10 ** -19 / 84 = 6.080361904761904E9
mircea_popescu: !~calc 6.023 * 10**23 * 5.3 * 10**6 * 1.6 * 10 ** -19 / 84
mircea_popescu: they have the p k, 1 < 4 ** (2 - sqrt(k))* k**2 , which is useful, but i also want the p k, m
ben_vulpes: > do not use * to mark line suppression
jhvh1: mircea_popescu: (200 / 3.6)**2 / 9.8 = 314.9407911312673
mircea_popescu: !~calc (200 / 3.6)**2 / 9.8
mircea_popescu: it's certainly not practical to simply say "i will just allocate lenM ** 2 bytes for s whenever hashing"
asciilifeform: * sageprobes has quit (Client Quit) << aww
phf: i'm pretty sure biggest overhead is in using adjustable arrays, because you lose out on using sbit instead of bit. sbit expects (simple-array bit (*)) and apart from doing basic type check it has very little overhead.
mircea_popescu: asciilifeform i can't really visually saw that appart, but looks like it's a hlen ** b mlen or such.
jhvh1: mircea_popescu: 300 * 3600 / .48 / .48 / .61 = 7684426.229508197
mircea_popescu: !~calc 300 * 3600 / .48 / .48 / .61
asciilifeform: eff, 'cypherpunks', cygnus, alt.* , gnuradio...
asciilifeform: and when test is 0x2fffffff.....ff * 0x4ffffffff....fff (8192 b.) so as no 0s to 'cheat' with, then they : 0.7s
asciilifeform: 0xFFFFFFFFFFFFFFFF ** 0x80 was picked because the answer actually occupies 8192 bits.
mircea_popescu: 0x1(0)FF** 0x1
asciilifeform: computation of 0xFFFFFFFFFFFFFFFF ** 0x80
a111: Logged on 2017-06-18 23:30 asciilifeform: and realized, while doing this, that in fact you don't need 2k+2 bits for the karatsuba intermediates, you can do instead of (x0+x1)*(y0+y1) , (x0-x1)*(y0-y1), and then you don't need to propagate carries, but only take absolutevalue and xor the borrows to see if gotta invert the resulting term
mircea_popescu: * deedbot gives voice to hanbot << somehow this struck me as quite funny :D
mircea_popescu: asciilifeform * sn0wmonster (~yeti@taskhive/lead/sn0wmonster) has left #trilema ("Leaving") <
a111: Logged on 2017-06-18 23:30 asciilifeform: and realized, while doing this, that in fact you don't need 2k+2 bits for the karatsuba intermediates, you can do instead of (x0+x1)*(y0+y1) , (x0-x1)*(y0-y1), and then you don't need to propagate carries, but only take absolutevalue and xor the borrows to see if gotta invert the resulting term
asciilifeform: and realized, while doing this, that in fact you don't need 2k+2 bits for the karatsuba intermediates, you can do instead of (x0+x1)*(y0+y1) , (x0-x1)*(y0-y1), and then you don't need to propagate carries, but only take absolutevalue and xor the borrows to see if gotta invert the resulting term ☟︎☟︎
mircea_popescu: but yes alf is correct i did base 10 for convenience because most people don't have base 2 mult table loaded in head so dunno what 110 * 101 is
mircea_popescu: mod6 because (a + b) * (c + d) = a (c + d) + b (c +d) = ac + ad + bc + bd. now, in our case, we were doing 11 * 11 and so a = 10 AND c = 10, while b = 1 AND d = 1, and so if you replace you yahve 10 * 10 + 10 * 1 + 1 * 10 + 1 * 1. because 10 * 1 = 1 * 10 you can just write it down as 2 * 10 * 1.
asciilifeform: p2*(2**32) + (p1-p2-p0)*(2**16) + p0 ==
asciilifeform: p1 = ( (X0 + X1) * (Y0 + Y1) )
asciilifeform: (X0 + X1) * (Y0 + Y1) == 0x3fff80004
mod6: <+mircea_popescu> trivially, 11 * 11 = 121, and also (10 + 1) * (10 + 1) = 10 * 10 + 2 * 10 * 1 + 1 * 1 = 121. << what I can't figure out is where the part: + 2 comes from.
mircea_popescu: that 10 is 1 * 10 ^ 1 ie first part * 2 ^ k.
mircea_popescu: trivially, 11 * 11 = 121, and also (10 + 1) * (10 + 1) = 10 * 10 + 2 * 10 * 1 + 1 * 1 = 121.
mircea_popescu: mod6 you take a number of say 22 bits, and cut it in two 11 bit numbers. this 11 is the k. then you have first part * 2 ^ K (=11) + second part to get the original back
mod6: is this like taking the low-order bits of X0*Y0 << 2*(WORD_SIZE), and (((X0+X1)*(Y0+Y1) - X0*Y0 - X1*Y1) << WORD_SIZE ?
mircea_popescu: a * b = (a1+a2)*(b1 + b2) = etc
mircea_popescu: a = a1 * 10^x + a2 ; b = b1 * 10^x + b2
a111: Logged on 2017-06-17 17:52 asciilifeform: ( (X0*Y0) << 2K ) + (((X0+X1)*(Y0+Y1) - X0*X1 - X1*Y1) << K) + X1*Y1 .
asciilifeform: http://btcbase.org/log/2017-06-17#1671496 << err, ( (X0*Y0) << 2K ) + (((X0+X1)*(Y0+Y1) - X0*Y0 - X1*Y1) << K) + X1*Y1 . ☝︎
asciilifeform: so, for instance, if X and Y were 32-bit integers, the term (X0+X1)*(Y0+Y1) is actually 34 bits wide.
asciilifeform: ( (X0*Y0) << 2K ) + (((X0+X1)*(Y0+Y1) - X0*X1 - X1*Y1) << K) + X1*Y1 . ☟︎
asciilifeform: i'll review karatsuba here, ftr. suppose you have 2 L-bit numbers, X and Y, to multiply. you can multiply X*Y the usual way, is O(N^2). but instead anatoly alexeevich k. shows us that you can cut X into X0,X1, ceil(x/2) and floor(x/2) bits, respectively, and same to Y, -> Y0,Y1, and then you only gotta do THREE multiplications, X0*Y0, X1*Y1, (X0+X1)*(Y0+Y1)
a111: Logged on 2017-06-12 16:15 asciilifeform: !~later tell Framedragger l0gz feature request -- turn the href in links to *.bitcoin-assets.com into btcbase ( printed text of link can remain same, in principle )
jhvh1: asciilifeform: 40 * 7 * 650 * 4184 / ( 34.2 * 10**6 ) = 22.265730994152047
asciilifeform: !~calc 40 * 7 * 650 * 4184 / ( 34.2 * 10**6 )
mircea_popescu: i dunno dood, the whole reason "Cowboy" was even possible at all was that chicago canneries (where all the cowboys were headed) got rail link to new york, where all the corned * got et.
asciilifeform: !~later tell ben_vulpes l0gz feature request -- turn the href in links to *.bitcoin-assets.com into btcbase ( printed text of link can remain same, in principle )
asciilifeform: !~later tell Framedragger l0gz feature request -- turn the href in links to *.bitcoin-assets.com into btcbase ( printed text of link can remain same, in principle ) ☟︎
asciilifeform: !~later tell phf l0gz feature request -- turn the href in links to *.bitcoin-assets.com into btcbase ( printed text of link can remain same, in principle )
sina: ben_vulpes: M = [0] * 32
sina: + flip(b, ((i+1 * M_pos) % len(b)))
sina: - flip(b, ((i * M_pos) % len(b)))
sina: cos I test with "M = [1] * 32"
sina: + * We expand S and screw R in S.
sina: - * We screw S in R.
mircea_popescu: so there's ~1.25 * lenM ish steps
mircea_popescu: * rnd(byte)/16 comes out even
mircea_popescu: and it keeps going from there, next step eg (-2 * 35 * 7 x + 14 * 35 * 7) / 16**2
mircea_popescu: you end up with fn initialized as say -2 x + 14 and then on the first pas it becomes say -2 * 35 / 16 x + 14 * 35 / 16
a111: Logged on 2015-09-14 00:35 mircea_popescu: * trinque [...] a very angry man about why what I did was below what was expected of me << for the record, i don't think very much of this entire "expectations" verbiage/bs. if you think a little about it, so would you. a) what sort of fucking powerless vulnerable schmuck lets himself get into the position of DEPENDING on a kid ? that's what you're saying. don't say that, not only is it not true it's also very stupid.
asciilifeform: http://btcbase.org/log/2017-06-06#1666711 << erratum -- it ain't (perhaps obviously) a null, it's a (void *)-1 ☝︎
asciilifeform: 'Existing implementations of mmap() return the value -1 when unsuccessful. Since the casting of this value to type void * cannot be guaranteed by the ISO C standard to be distinct from a successful value, this volume of POSIX.1-2008 defines the symbol MAP_FAILED, which a conforming implementation does not return as the result of a successful call.'
danielpbarron: but i think even if you accidentally agree to use changes, it'll put them in a ._* hidden file that you still have to manually mv to the correct place
trinque: seems the cautious move, right? show me what you're going to do, shithead. but no, means HOLD MY BEER; I'M GOING TO CHANGE /etc/portage/*
jhvh1: mircea_popescu: 8.5 * 10**6 / 2513.24281176 = 3382.084675713259
mircea_popescu: !~calc 8.5 * 10**6 / 2513.24281176
ben_vulpes: mayer alan brenner *
ben_vulpes: mayer allan brenner *
phf: no idea, nock(..) doesn't work, so i did a substitution to *[57 [4 [0 1]]] and it gave me 1
jhvh1: asciilifeform: 8750*2 * 0.75 = 13125
asciilifeform: !~calc 8750*2 * 0.75
pete_dushenski: this is actualy the legacy of the whole gay right movement innit : everyone and their dog is *-oriented. such human social progress this advent.
jurov: (*) submersible only once
asciilifeform: theoretically this set will include some (largeprime)*(largeprime) folx.
asciilifeform: so to get X * Y -> product, carry
jhvh1: mircea_popescu: 40 * 7 / 30 = 9.333333333333334
mircea_popescu: !~calc 40 * 7 / 30
asciilifeform: every single subcomponent has to run at ~worst case~ complexity at all times. i.e. 0**0 takes same time as (2**8192)**(2**8192).
asciilifeform: a 'schoolbook' (word-by-word, using * (which will compile to IMUL instr on x86) multiplier will be faster than the 'egyptian' one. the catch is,
mircea_popescu: 4 * 5 mod 6 = 4. (6-4)*5 mod 6 = 4. 7*5 = 35 mod 6 = 5. 1*5 mod 6 = ...
mircea_popescu: (12 * 5) mod 6 = 0, yes ?
mircea_popescu: incidentally : "define *' so that modx(a * b) = modx(a) *' modx(b)" should be a legitimate abstract algebra approach.
jhvh1: asciilifeform: 2.13 * 10**-13 * ( 6.022 * 10**23 ) / ( 4.184*10**6 ) = 30656.931166347993
asciilifeform: !~calc 2.13 * 10**-13 * ( 6.022 * 10**23 ) / ( 4.184*10**6 )
jhvh1: asciilifeform: 2.13 * 10**-13 * ( 6.022 * 10**23 ) = 1.2826859999999998E11
asciilifeform: !~calc 2.13 * 10**-13 * ( 6.022 * 10**23 )
jhvh1: mircea_popescu: 2.13 * 10**-13 * 1.25*10**9 = 2.6625E-4
mircea_popescu: !~calc 2.13 * 10**-13 * 1.25*10**9
jhvh1: mircea_popescu: 500 / 1800 * 256 / 4.5 = 15.802469135802468
mircea_popescu: !~calc 500 / 1800 * 256 / 4.5
asciilifeform: on plus side, 'Support for the musl C library was added for the AArch64, ARM, MicroBlaze, MIPS, MIPS64, PowerPC, PowerPC64, SH, i386, x32 and x86_64 targets. It can be selected using the new -mmusl option in case musl is not the default libc. GCC defaults to musl libc if it is built with a target triplet matching the *-linux-musl* pattern.'
jhvh1: mircea_popescu: 175 * 175 / 12 = 2552.083333333333
mircea_popescu: !~calc 175 * 175 / 12
jhvh1: mircea_popescu: 60 * 1.6 / 3.6 / 10 = 2.666666666666667
mircea_popescu: !~calc 60 * 1.6 / 3.6 / 10
trinque: * wget -r
jhvh1: mircea_popescu: 46 * 63 * .82 = 2376.3599999999997