| Age | Commit message (Collapse) | Author |
|---|
|
because it's not public API!
|
|
The backing constants of NumberType and TotativeType have been changed
so that they can be compared (based on how desirable they are, more
desirable categories are given higher values), and so that I can add new
values in between without changing the constants.
|
|
These radices are large enough that:
- there is no reason to use them as actual radices
- calculating them takes a lot of time!
Therefore, the exact MTC and radix type shouldn't be calculated by
default. If you want to take the time, you still can with -l. I am
keeping the original 2^32 limit even with -l, because the problem with
that is not performance, it is that the resulting MTC could overflow a
uint64 (also the CAN list only goes up to this range).
|
|
This can easily be estimated from existing information, so it's useful
to have, even in the compact view.
This estimate is more accurate (narrows the range down further) the
higher the radix's totative ratio. It also should be closer to the
actual value than the upper bound.
|
|
This value can easily be calculated as φ(r)/r. There is no need to have
this now that I have a function φ(r) (renamed to its mathematical name,
Totient).
I removed totative ratio instead of totient because, while it is more
important, totient is an integer while totative ratio is a float. This
means that the totative ratio can be calculated exactly from the
totient, but not the other way round.
|
|
Full digit maps will show every digit from 0 to 35, regardless of the
radix. This allows you to see extra fractions for small radices and to
get a digit map for radices above 36.
This isn't enabled by default because the extra "digits" added for small
radices aren't actually digits - so it may be unintuitive. There are
also some situations where only a radix's actual digits matter, such as
multiplication tables.
|
|
It now distinguishes between omega (factors of r - 1), alpha (factors of
r + 1) and the rest. The previous categorization determined whether or
not totatives and semitotatives have simple patterns; this new
categorization determines which simple patterns they follow)
|
|
In general, components go in the order Factors → Totatives → Size. 2345
Score was moved to fit this order, since it concerns both factors (2-5)
and totatives (5). The compact view was rearranged to have a consistent
order with the normal view.
Also I added the MTC estimate for very large radices into the compact
view, because it can be there.
|
|
The compact output attempts to maximize the power-to-weight ratio of
this program, and the 2345 Score does not do this:
- It can already be easily determined from the prime factorization and
decimal radix, or trivially determined from the digit map.
- It does not take mixed radices (the radices you'll need to use bases
large enough to not show a digit map) into account.
- Although a big part of the 2345 Rank is strict improvements, some of
the decisions made in its design were necessarily arbitrary. The
alternatives give a more objective view.
The normal output is about showing everything worth showing, and the
2345 score is still useful there (especially for making sense of the
resulting complexity), so it is not removed from there.
|
|
This is done for a few reasons:
- Allow the user to easily determine the exact value of the totative
ratio
- This information is important when the digit map isn't accessible (for
radices >36)
- More consistency with factors
I don't show the exact values of totatives like I do with factors
because they're far more common - the superior highly composite (i.e.
one of the numbers with the highest factor count) number 720720 has
240 factors and 138240 totatives, for example.
|
|
|
|
The non-compact display is intended as a "full info" display, so it
makes sense to have more precision in these numbers. The compact
display is unchanged.
|
|
|
|
|
|
This achieves two things:
- Decouples my code by putting the printing code into its own file
- Makes it easier to make alternate ways of printing (e.g. a compact
mode)
|
|
|
|
|
|
This is not in the output yet, but it will be soon - printing it is
another task since I want colours in my output.
|
|
(or, as exact as possible within a float64 - I only do one float
division, and everything else is a uint, so I think this means I will
get the closest available float64 value every time)
|
|
This ensures the output can fit into a uint64. Also, calculating it at
this stage is slow, and not calculating it can make the program nearly
instant even for very large numbers!
|
|
This type measures which kind of classes each radix is a part of:
- Colossally Abundant (OEIS: A004490; factor score better than every
other number if you account for size be dividing by a certain power of
the number)
- Superabundant (OEIS: A004394; factor score better than every smaller
number)
- Ordered-Exponent (OEIS: A025487; exponents in prime factorization go
down as you get to bigger primes, and no prime is skipped)
- Practical (OEIS: A005153; factors can sum to any number below the
original number without duplication)
Each of these groups is a subset of the next, so only the most specific
label is reported.
The purpose of this program is to give you useful info to help you
determine which radices are the best, and these categories give a rough,
quantitative measure of how useful a radix's factors are:
- Practical is approximately the minimum requirement for a worthwhile
radix. Non-practical radices above ~16 are probably terrible to use.
- Ordered-Exponent radices act like local maxima - you can't get any
better (smaller) without changing the "shape" (exponents) of your prime
factorization.
- Superabundant radices are the best radices below the next
superabundant number (e.g. 12 is the best radix below 24).
- Colossally abundant radices are, in some sense, the best radices out of
all numbers.
|
|
A radix's logarithm determines how well it compresses digits - a higher
logarithm means numbers will take up fewer digits. If c =
log(a)/log(b), then numbers in radix b will be around c times longer
than numbers in radix a.
|
|
(MTC = Multiplication Table Complexity)
|
|
Use methods from the new slices and maps modules to make my code faster
and more compact.
|
|
I can now use the function tableTest() to create a new test in one or
two lines of code! No more need to rewrite basically the same code ten
times...
|
|
|
|
|
|
|
|
|
|
|
|
|
