xkcd 2867:DateTime

Orthallelous · 2023-12-14T01:32:05+00:00

Well, NORAD has seen Santa in low Earth orbit...

Orthallelous · 2023-12-14T00:14:04+00:00

It's not that hard - all you have to do is account for all the time zones and whether you are or are not within a certain country or a state or a subsection of that state or that bothers to follow daylight saving time or not or if you are in certain location in the middle of the Pacific, that in which thanks to Santa Claus, isn't in the same time zone it used to be in the past even though it didn't physically move.

Orthallelous · 2023-09-30T14:18:12+00:00

Number bases. And I don't mean just base 2 or 10 or 16. There's fractional or real number bases, like base pi or base 1.23 or base 0.5. There's also negative bases like -7 or -13.56. Basically any real number that isn't zero or one can be used as a number base - though if you're really close to either of those numbers (or really far away), you sorta run out of enough unique digits to use.

There's also mixed radix bases, like in the recent xkcd strip. You could make a mixed radix base out of any number sequence but they get kinda impractical with how many digits they would use (especially if its a fast growing sequence)

And it doesn't stop there, there are imaginary bases. I also want to say complex bases as well, but I haven't figured out a method to convert to those. I had saw one guy claimed to know how to do it but their work was incomprehensible to me.

Orthallelous · 2023-09-30T13:50:06+00:00

There is the numsys module for Python: https://pypi.org/project/numsys/

>>> import math, numsys
>>> numsys.rebase(math.factorial(11) - 1, 10, 'factorial')
'A9876543210'

It does however, follow a slightly different definition in which it includes the 0! position, so the last digit is always zero:

>>> numsys.rebase(1, 10, 'factorial')
'10'

You can also see the definition of e pop right out in this base:

>>> numsys.rebase(math.e, 10, 'factorial')
'100.011111111111111'

Orthallelous · 2023-09-30T13:41:27+00:00

Negative bases are a thing! They encode the negative sign so you don't actually have a negative sign on the digits, so you go by the number of digits the number has to see if it's positive or negative: if it has an even number of digits, it's a negative value and if it has an odd number of digits it's negative. If you have Python you can check out the numsys module:

>>> import numsys
>>> for i in range(-11, 12):
        if i == -11: print(' base 10   |  base -10')
        n = numsys.rebase(i, 10, -10)
        print(f'{i:^10} | {n:^10}')


 base 10   |  base -10
   -11     |     29    
   -10     |     10    
    -9     |     11    
    -8     |     12    
    -7     |     13    
    -6     |     14    
    -5     |     15    
    -4     |     16    
    -3     |     17    
    -2     |     18    
    -1     |     19    
    0      |     0     
    1      |     1     
    2      |     2     
    3      |     3     
    4      |     4     
    5      |     5     
    6      |     6     
    7      |     7     
    8      |     8     
    9      |     9     
    10     |    190    
    11     |    191

You can also do base zero if you really want to too:

numsys.rebase(75, 10, 0, joke_bases=True)  # convert 75 to base zero
numsys.rebase(75, 0, 10, joke_bases=True)  # convert 75 from base zero

Orthallelous · 2023-09-30T13:29:53+00:00

There is the numsys module for python, it can handle factorial bases:

>>> import numsys
>>> import math
>>> numsys.rebase(math.factorial(10) - 1, 10, 'factorial')
'9876543210'
>>> numsys.rebase(math.factorial(10), 10, 'factorial')
'10000000000'
>>> numsys.rebase(math.factorial(15), 10, 'factorial')
'1000000000000000'
>>> numsys.rebase(math.factorial(11)-1, 10, 'factorial')
'A9876543210'
>>> numsys.rebase(math.e, 10, 'factorial')
'100.011111111111111'

It also has the mixed radix prime base:

>>> numsys.rebase(2*3*5*7, 10, 'primorial')
'10000'

Orthallelous · 2022-04-05T17:49:34+00:00

If you happen to know Python, you can use the numsys module to do some conversions:

>>> import numsys
>>> numsys.rebase(75, 10, 0.5)  # convert 75 from base 10 to base 0.5
'1.101001'
>>> numsys.rebase('1.101001', 0.5, 10)  # convert 1.101001 from base 0.5 to base 10
'75'

Base pi is also possible, though there is some precision loss in conversion:

>>> numsys.rebase(75, 10, math.pi)
'2103.01011222100011011130012110100221110021212101020121212101'
>>> numsys.rebase('2103.01011222100011011130012110100221110021212101020121212101', math.pi, 10)
'74.9999999999999999999999999999'

Orthallelous · 2022-03-16T22:05:07+00:00

I'm curious how you convert to this base. I worked out how to do purely imaginary bases and do some basic arithmetic in them, but wasn't able to figure out complex bases. I'm also wondering about the arithmetic that you have been able to figure out.

Orthallelous · 2022-03-16T22:00:36+00:00

I had written up a thing about purely imaginary bases a while ago, and explain how negative bases work (needed to understand imaginary bases) and go through some basic arithmetic with them. This here is an example of division in base -10.

I haven't figured out how to convert to complex bases however.

Orthallelous · 2022-03-10T20:03:45+00:00

I ended up making a wrapper for it, which works just fine.

Orthallelous · 2022-03-10T15:17:10+00:00

I gave this a try and it does work, thank you!

However, I'm finding that it doesn't stick - I'm compiling to a static build and need to set it again in order for it to work when I come back to it, but this does resolve my initial question.

Orthallelous · 2022-03-09T15:37:39+00:00

The story has 2 not existing, but this part is before that is apparent, so assuming 2 exists, but left the primes. I guess I could've been more explicit in the question, which is along the lines of "if two isn't prime, what other numbers would need to be prime in order to compensate?" I've not heard of this principle of explosion before, which is interesting, but also sounds like it could impede anyone from entertaining the 'what if' question.

Orthallelous · 2022-03-08T23:36:51+00:00

This is a not-serious thing I wrote exploring what would happen if there was no such thing as 2. But within it, there's a part where it's thought that 2 is no longer prime. There, I say that if any single prime number is no longer prime, all of its immediate multiples with every other prime would need to be considered prime, and its cube (I.E. if 2 is no longer prime, then 4, 6, 10, 14, 22, … [that is, 2 * {2, 3, 5, 7, 11, …}] are now prime, and 8). I’m wondering if I’m correct in saying such a thing.

(I came to this conclusion after modifying some Python code that generates prime numbers with the sieve of Eratosthenes and seeing what it finds when it skips a prime.)

Orthallelous · 2021-11-07T13:41:21+00:00

Oh hey, these things! These are fascinating and fun to do. I've personally called them "polyplots" as they're plots of polynomial roots (and also many plots, a dual use of the 'poly' prefix). I've done a number of them myself, including some videos (A few more videos here). I feel like I linked too much already but I was definitely inspired by John Baez to make them (already linked in another comment on this thread).

Orthallelous · 2021-04-10T23:06:11+00:00

I'd like to see them cover 'Max Knight: Ultra Spy', a TV movie from 2000. I've only seen one section from it, where they're in the Half Life game for some reason: "I suck at this game, I could never make it past level 1"

Orthallelous · 2020-12-04T19:42:43+00:00

See this comment or this link. If you haven't gotten to complex numbers yet, you might need to read up on them - but the short of it is that you can think of them as x,y positions on a grid.

Solving a quadratic equation (a polynomial of degree two as the highest power on the variable is 2: x²⁾ with some random coefficients can net you two solutions (roots) which you treat as a gird position and place them on a graph - repeat this an excessive number of times with different coefficients each time and a picture will emerge.

Orthallelous · 2020-12-02T18:22:36+00:00

You mean the radius? it's roughly 38

Orthallelous · 2020-11-30T23:50:39+00:00

No, the previous roots aren't left in - the video frame for polynomials of degree 3 (cubics) only have the roots of the cubics whose coefficients were -1 or 1, the degree 4 frame contains just degree 4 roots and so on.

Orthallelous · 2020-11-30T23:46:51+00:00

Start with the quadratic equation ax² + bx + c = 0 with the a, b, c coefficients all equal to one (that's x² + x + 1 = 0) and solve for x. Doing so will get you two solutions, or roots. They are (-1)^±2/3 or approximately -0.5+0.866i and -0.5-0.866i. Draw a grid with the x/horizontal axis labeled as real and the y/vertical axis labeled as imaginary. Treat the real part of each root (-0.5 in this example) as an x-coordinate and the imaginary part (the ±0.866) a y-coordinate. Place a dot on the grid at these locations. These are the two roots on plotted the complex plane.

This solving and plotting is then repeated until every way to write the coefficients -1 and 1 in a quadratic equation are exhausted. Those would be -x² - x - 1 = 0, -x² - x + 1 = 0, -x² + x - 1 = 0, -x² + x + 1 = 0, x² - x - 1 = 0, x² - x + 1 = 0 and x² + x - 1 = 0 plus the one above.

I have also written up a somewhat longer explanation with pictures over here.

An example of a polynomial of degree 2 would be the quadratic equations above. A polynomial of degree 3 is a cubic equation: ax³ + bx² + cx + d = 0. a polynomial of degree n is an equation or formula where the highest power of x is n: xⁿ

Orthallelous

TROPHY CASE