Fixed-point arithmetics

As other people mentioned, things like the decimal structure works well, but you can also just use an int to store how many pennies something costs and convert it to dollars for display.

Use a dedicated data type or library. Some languages also have something like python's Decimal type

>>> .1 + .2
0.30000000000000004
>>> Decimal(".1") + Decimal(".2")
Decimal('0.3')

The same IEEE spec that introduced base-2 floating point models was updated in 2008 to include some base-10 models that eliminate these issues. Many languages already support them natively, as well as most database engines. Otherwise, you can probably find third-party-library support.

If you don't have access to an IEEE decimal implementation, or if you just wanna be a rulebreaker, the common strategy is to just store only plain integers, and the precision level you want. So, say, if you're just dealing with simple american dollars, you'd just make sure to always interpret the integer value as "cents". If you need more precision than that, you might do "millicents".

Weird. My wget gives full resolution. No redirect options or anything. Only difference is the IP resolve for you is in Korea and mine is in the US. Likely just closest server resolve.

Try curl with -L set?

Or I'd be curious if something like gallery-dl resolves the image in finding the higher resolution and what the difference is if it does.

Maybe it's a DNS issue if not a redirect issue.

My guess is DNS. Try with another provider?

How many decimal places can it be stretched?

As usual, the best jokes are in the comments. (Though goddamn I chuckled at the meme.)

Do you have a computer type that can represent the entire rational set?

Aside from the fact that there are infinitely many rationals but only finite sized computer you can just represent them as a ratio:

struct Rational {
    numerator: BigInt,
    denominator: BigInt,
}

The real fun are the rationals, as they contain uncomputable numbers. The computable rationals can be represented as:

struct Rational {
    exponent: BigInt,
    digits: fn(BigInt)->Byte,
}

No. They all need to mimic certain numbers.