Arithmetic system of 2-adic numbers in scheme language
2-adic numbers are represented by infinite streams in binaries. All arithmetic operations provided are accurate.
Run with Chez Scheme
-
binaries-zero:2-adic zero.
-
binaries-one:2-adic one.
-
binaries-minus-one:2-adic minus-one.
-
(r-binaries r):Construct a 2-adic number from a rational number
r. -
(h-binaries h):Construct a 2-adic number from an infinite stream of hexes
h. -
(display-binaries b n):Display a 2-adic number
bby hex digits.If
nis a positive integer or#t, scientific notation is enabled, andnhex digits or infinite digits will be displayed.If
nis a non-positive integer or#f, the fractional part will be displayed in full and the integer part will shownor infinite digits.If
nis omitted, it will be regarded as#f.
Construct and display a rational number ⁷/₁₃.
> (display-binaries (r-binaries 7/13) -50)
.36726726726726726726726726726726726726726726726726...
Construct an infinite series
2 + 3 × 16 + 5 × 16² + 7 × 16³ + 11 × 16⁴ + ⋯ + P(n+1) × 16ⁿ + ⋯
where P(k) is the k-th prime. Display in scientific notation.
> (define primes
(letrec ([integers (stream-cons 3
(stream+ (ns 1) integers))])
(stream-cons 2
(stream-filter
(lambda (n)
(let ([m (isqrt n)])
(let loop ([ps primes])
(cond [(> (stream-car ps) m) #t]
[(zero? (remainder n (stream-car ps))) #f]
[else (loop (stream-cdr ps))]))))
integers))))
> (define binaries-primes (h-binaries ($stream-carry primes)))
> (display-binaries binaries-primes 50)
[1]99ABDE02478BDE0478BDE147BDE024BD0278BE0478DE028E02...
-
(binaries+ b1 b2 ... bn):Construct a 2-adic number
b1 + b2 + ⋯ + bn. -
(binaries- b1 b2):Construct a 2-adic number
b1 - b2.If
b1is omitted, it will be regarded as zero. -
(binaries* b1 b2):Construct a 2-adic number
b1 × b2. -
(binaries*r b r):Construct a 2-adic number
b × r, whereris a rational number. -
(binaries-shift b n):Construct a 2-adic number
b × 2ⁿ, wherenis an integer. -
(binaries/ b1 b2):Construct a 2-adic number
b1 / b2.If
b1is omitted, it will be regarded as one.
Since all the results are represented by infinite streams, a 2-adic number that is theoretically zero cannot be calculated to be zero. In binaries, if a certain number of zero digits are detected, it will be judged as a potential zero. Functions below are provided for dealing with potential zeros.
-
(binaries-zero? b):Test if a 2-adic number
bis zero, non-zero or potential zero.If
bis zero, it will return#t; ifbis non-zero, it will return#f.If
bis a potential zero, it will return an integernindicating thatbis divisible by2ⁿ. -
(binaries-eval b n):Evaluate a potential zero to the given binary bits
nuntil it be determined to be non-zero.It will return
#tifbis evaluated to be non-zero,#felse.If
nis omitted, then there is no limit to the number of bits in the evaluation before determination. Any theoretical zero number will result in endless computations.
Potential zeros cannot be used as a divisor.
Ordinary operations may yield potential zeros:
> (define pot-zero-0 (binaries- one-binaries one-binaries))
> (binaries-zero? pot-zero-0)
200
A construction from infinite stream may also yield potential zeros:
> (define pot-zero-1 (h-binaries (hexes-shift one-hexes 200)))
> (binaries-zero? pot-zero-1)
200
A shift operation will not change the state of zero:
> (define non-zero-small (binaries-shift one-binaries 800))
> (binaries-zero? non-zero-small)
#f
> (binaries-zero? (binaries-shift pot-zero-1 -800))
-600
> (binaries-zero? (binaries-shift zero-binaries -800))
#t
Addition of multiple parameters is recommended, as this will reduce the possibility of potential zeros appearing:
> (define one-plus-small (binaries+ one-binaries non-zero-small))
> (define pot-zero-2 (binaries- one-plus-small one-binaries))
> (binaries-zero? pot-zero-2)
200
> (binaries-zero? (binaries+ one-binaries one-plus-small minus-one-binaries))
#f
We can see that three numbers pot-zero-1, non-zero-small and pot-zero-2 are theoretically equal. Do some more calculations involving potential zeros:
> (define pot-zero-3 (binaries+ pot-zero-1 pot-zero-2))
> (binaries-zero? pot-zero-3)
200
> (binaries-zero? (binaries+ non-zero-small pot-zero-2))
#f
> (define pot-zero-4 (binaries- non-zero-small pot-zero-2))
> (binaries-zero? pot-zero-4)
1000
> (define pot-zero-5 (binaries* pot-zero-3 pot-zero-3))
> (binaries-zero? pot-zero-5)
400
> (binaries-eval pot-zero-5 1000)
#f
> (binaries-eval pot-zero-5)
#t
> (display-binaries pot-zero-5 50)
[1602]10000000000000000000000000000000000000000000000000...
> (display-binaries (binaries/ pot-zero-3 non-zero-small) -50)
.20000000000000000000000000000000000000000000000000...
> (display-binaries (binaries/ non-zero-small pot-zero-3) -50)
Exception in binaries/: Division by potential zero.
> (binaries-eval pot-zero-3)
#t
> (display-binaries (binaries/ non-zero-small pot-zero-3) -50)
8.00000000000000000000000000000000000000000000000000...
-
(binaries-square b):Construct a 2-adic number
b². -
(binaries-expt b n):Construct a 2-adic number
bⁿ, wherenis an integer. -
(binaries-sqrt? b):It will return
#tifbis zero or non-zero that has square roots,#felse. -
(binaries-sqrt b index):Construct a 2-adic number
√b. If integerindexis even, then the odd part in the scientific notation of result≡ 1 mod 4, else≡ 3 mod 4.If
indexis omitted, it will be regarded as0. -
(binaries-root? b n):It will return
#tifbis zero or non-zero that hasn-th roots,#felse. -
(binaries-root b n index):Construct a 2-adic number
ⁿ√b, wherenis a non-zero integer. In the case thatnis even, if integerindexis even, then the odd part in the scientific notation of result≡ 1 mod 4, else≡ 3 mod 4.If
indexis omitted, it will be regarded as0. -
(binaries-exp b):Construct a 2-adic number
exp(b). It should hold thatb ≡ 0 mod 4. -
(binaries-log b):Construct a 2-adic number
log(b). It should hold thatb ≡ 1 mod 2. -
(binaries-pow b1 b2):Construct a 2-adic number
pow(b1, b2). It is defined to beexp(b2 × log(b1)). -
(binaries-sin b):Construct a 2-adic number
sin(b). It should hold thatb ≡ 0 mod 4. -
(binaries-cos b):Construct a 2-adic number
cos(b). It should hold thatb ≡ 0 mod 4. -
(binaries-tan b):Construct a 2-adic number
tan(b). It should hold thatb ≡ 0 mod 2. -
(binaries-asin b):Construct a 2-adic number
arcsin(b). It should hold thatb ≡ 0 mod 4. -
(binaries-acos b index):Construct a 2-adic number
arccos(b). It should hold thatb ≡ 1 mod 8and that1 - b²has square roots. If integerindexis even, then the odd part in the scientific notation of result≡ 1 mod 4, else≡ 3 mod 4.If
indexis omitted, it will be regarded as0. -
(binaries-atan b):Construct a 2-adic number
arctan(b). It should hold thatb ≡ 0 mod 2. -
(binaries-sinh b):Construct a 2-adic number
sinh(b). It should hold thatb ≡ 0 mod 4. -
(binaries-cosh b):Construct a 2-adic number
cosh(b). It should hold thatb ≡ 0 mod 4. -
(binaries-tanh b):Construct a 2-adic number
tanh(b). It should hold thatb ≡ 0 mod 2. -
(binaries-asinh b):Construct a 2-adic number
arcsinh(b). It should hold thatb ≡ 0 mod 4. -
(binaries-acosh b index):Construct a 2-adic number
arccosh(b). It should hold thatb ≡ 1 mod 8and thatb² - 1has square roots. If integerindexis even, then the odd part in the scientific notation of result≡ 1 mod 4, else≡ 3 mod 4.If
indexis omitted, it will be regarded as0. -
(binaries-atanh b):Construct a 2-adic number
arctanh(b). It should hold thatb ≡ 0 mod 2.
The following code constructs a number α satisfying α⁻²⁸ + 15 = 0 and verifies that α²³ - α⁹ / √-15 = 0.
> (define r-15 (r-binaries -15))
> (define sqrt-15 (binaries-sqrt r-15))
> (display-binaries sqrt-15 -50)
.9D44EED7085922F66E2026FB6C24DF22C0523BCA43D8A7B7E5...
> (define alpha (binaries-root r-15 -28))
> (display-binaries alpha -50)
.540CE8D70746CCB36DD9D74161E23D98177655CEA52763E19A...
> (display-binaries
(binaries-
(binaries-expt alpha 23)
(binaries/
(binaries-expt alpha 9)
sqrt-15))
-50)
.00000000000000000000000000000000000000000000000000...
The following code calculates ((43 √-15 + 26 √41)² + 2⁴ + 1 + 1 + 1)⁶.
> (define r+41 (r-binaries 41))
> (define sqrt+41 (binaries-sqrt r+41))
> (display-binaries sqrt+41 -50)
.DC66CC00EFB622B945B363D9C09AC784C104795047307E7C73...
> (define beta (binaries+
(binaries*r sqrt-15 43)
(binaries*r sqrt+41 26)))
> (display-binaries beta -50)
.54108CB31641E4C6C4388FC1AA2633D39EBB37391A11C0B098...
> (define x (binaries-expt
(binaries+
(binaries-square beta)
(binaries-shift one-binaries 4)
one-binaries one-binaries one-binaries)
6))
> (display-binaries x -50)
.000966C0B552B5CC09E3112AFFFFFFFFFFFFFFFFFFFFFFFFFF...
From the last output we can guess that the result is an integer. So if we don't limit the number of digits for display, the result will be
> (display-binaries x)
.000966C0B552B5CC09E3112AF(3920)^C
break>
The display function will detect consecutive occurrences of digit 0 or F in unlimited display mode. In that case, the number of 0 or F currently evaluated will be placed in the parenthesis and changes over time. We can press Ctrl-C to break the procedure.
The output indicates that the result of our expression is an hex integer -0x5DEEC16F33A4DAA4F3997000, that is -29070743726494498752382464000.
Recall that we have constructed a 2-adic number binaries-primes by infinite series before. Now we will calculate some trigonometric functions involving it and verify some identities.
> (define p (binaries+ binaries-primes (r-binaries 4)))
> (define 2p (binaries-shift p 1))
> (define sin+2p (binaries-sin 2p))
> (display-binaries sin+2p -50)
.CCCFB54B2A5E34A98B527FB5480B811129524A1EFFED9057DC...
> (define cos+2p (binaries-cos 2p))
> (display-binaries cos+2p -50)
.999550FF477BC9A04080262801F89A6ECE380027B2AFEB21FD...
> (define tan+2p (binaries-tan 2p))
> (display-binaries tan+2p -50)
.CAA54E78CB2101842651A3A8AC142FEE07749383649730BDBD...
> (define tan+p (binaries-tan p))
> (display-binaries tan+p -50)
.EF7B00122CF11254C3CF1E40CDB58E6706C5B53A7CEF7A31CF...
sin(2p)² + cos(2p)² = 1:
> (display-binaries (binaries+
(binaries-square sin+2p)
(binaries-square cos+2p))
-50)
.10000000000000000000000000000000000000000000000000...
sin(2p) = cos(2p) × tan(2p):
> (display-binaries (binaries-
sin+2p
(binaries* cos+2p tan+2p))
-50)
.00000000000000000000000000000000000000000000000000...
tan(2p) = 2 tan(p) / (1 - tan(p)²):
> (display-binaries (binaries-
tan+2p
(binaries-shift
(binaries/
tan+p
(binaries-
one-binaries
(binaries-square tan+p)))
1))
-50)
.00000000000000000000000000000000000000000000000000...
Then we will try inverse trigonometric functions:
> (display-binaries (binaries-asin sin+2p) -50)
.C6AE6B380D1E6B30D1E6B70DD6B380D638C1EA30D16B380A38...
> (display-binaries (binaries-acos cos+2p) -50)
.495194C7F2E194CF2E1948F2294C7F29C73E15CF2E94C7F5C7...
> (display-binaries (binaries-atan tan+2p) -50)
.C6AE6B380D1E6B30D1E6B70DD6B380D638C1EA30D16B380A38...
> (display-binaries (binaries-atan tan+p) -50)
.6357BD148E07BD18E07BD38E6BD1486B14E07D18E0BD140D14...
> (display-binaries (binaries-cosh (binaries-acosh r+41)) -50)
.92000000000000000000000000000000000000000000000000...
Notice that the result arccos(cos(2p)) is -2p, because p's odd part in the scientific notation ≡ 3 mod 4 . We can add the index parameter to get another result:
> (display-binaries (binaries-acos cos+2p 1) -50)
.C6AE6B380D1E6B30D1E6B70DD6B380D638C1EA30D16B380A38...
Exponential function exp always return an odd that ≡ 1 mod 4, so we have exp(log(p / 2)) = - p / 2:
> (define p/2 (binaries-shift p -1))
> (display-binaries p/2 -50)
.B9ABDE02478BDE0478BDE147BDE024BD0278BE0478DE028E02...
> (define log+p/2 (binaries-log p/2))
> (display-binaries log+p/2 -50)
.C527A125DC5C044112B1DB2F15539006E0C6AE9946F856F586...
> (define exp+log+p/2 (binaries-exp log+p/2))
> (display-binaries exp+log+p/2 -50)
.565421FDB87421FB87421EB8421FDB42FD8741FB8721FD71FD...
> (display-binaries (binaries+ exp+log+p/2 p/2) -50)
.00000000000000000000000000000000000000000000000000...
So pow(b, 1) is not necessarily equal to b, it may be equal to -b. We can think of it as some kind of absolute value function.
Recall that we have constructed some potential zeros, some of them are theoretically zero (pot-zero-0, pot-zero-4) and others are actually non-zero (pot-zero-1, pot-zero-2, pot-zero-3, pot-zero-5). We can apply analytic functions on them:
> (define exp+pot-zero-1 (binaries-exp pot-zero-1))
> (display-binaries exp+pot-zero-1 -50)
.10000000000000000000000000000000000000000000000000...
> (display-binaries exp+pot-zero-1 -2000)
.1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000085555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D28D2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2BC2B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B21B2116F99D2DBB0A448D766B4FE282116F99D2DBB0A448D766B4FE282116F99D2DBB0A448D766B4FE282116F99D2DBB0A448D766B4FE282116F99D2DBB0A448D766B4FE282116F99D2DBB0A448D766B4FE282116F99D2DBB0A448D766B4FE282116F99D2DBB09E...
> (define sin+pot-zero-2 (binaries-sin pot-zero-2))
> (binaries-zero? sin+pot-zero-2)
800
> (binaries-eval sin+pot-zero-2)
#t
> (binaries-zero? sin+pot-zero-2)
#f
> (display-binaries sin+pot-zero-2 2000)
[800]1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598598BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C95A298BC6405D33671FAF7ED02C986...
> (define atan+pot-zero-4 (binaries-atan pot-zero-4))
> (binaries-zero? atan+pot-zero-4)
1000
> (display-binaries atan+pot-zero-4)
.0(284980)^C
break>
We can see from here that all the calculations are certified.