One-to-one correspondence between pairs of integers and the positive integers
MATL, 43 36 bytes
This uses the spiral (1YL) function, which generates a square 2D array of given size with values arranged in an outward spiral. For example, with input 7 it produces
43 44 45 46 47 48 49
42 21 22 23 24 25 26
41 20 7 8 9 10 27
40 19 6 1 2 11 28
39 18 5 4 3 12 29
38 17 16 15 14 13 30
37 36 35 34 33 32 31
The center of the array, which contains 1, corresponds to the tuple [0 0]. The upper left corner corresponds to [-3 -3] etc. So for example f (-3,-3) will be 43 and g (43) will be [-3 -3].
The code generates a 2D array with this spiral matrix, as large as needed to do the conversion. Note that larger sizes always give the same result for the entries already included in smaller sizes.
From Z2 to N (18 bytes):
|X>tEQ1YLGb+QZ}3$)
Try it online!
|X> % input is a 2-tuple. Take maximum of absolute values
tEQ % duplicate. Multiply by 2 and increase by 1. This gives necessary size of spiral
1YL % generate spiral
G % push input 2-tuple again
b+Q % bubble up, add, increase by 1. This makes the center correspont to [0 0]
Z} % split tuple into its values
3$) % use those two value as indices into the spiral array to obtain result
From N to Z2 (25 18 bytes)
Eqt1YLG=2#fhw2/k-q
Try it online!
Eq % input is a number. Multiply by 2, add 1. This assures size is enough and odd
t1YL % duplicate. Generate spiral of that size
G= % compare each entry with the input value
2#fh % 2-tuple of row and column indices of matching entry
w2/k-q % swap. Offset values so that center corresponds to [0 0]
Snippet for checking
Note that G needs to be modified to accomodate the fact that we have don't have a single input. The code is slow, so the link checks tuples with values from -9 to 9 only. For -99 to 99 just replace the first line.
The code tests each tuple with values in the defined range. It does the conversion to a number, then from that number back to a tuple, and then checks if the original and recovered tuple are equal. The results should all be 1, indicating that all comparisons give true.
It takes a while to run.
Try it online!
-9:9 % Or use -99:99. But it takes long
HZ^!"@ % Cartesian power: gives tuples [-9 -9] ... [9 9].
% For each such tuple
|X>tEQ1YL@b+QZ}3$) % Code from Z^2 to N with `G` replaced by `@` (current tuple)
XJ % Copy result into clipboard J
Eqt1YLJ=2#fhw2/k-q % Code from N to Z^2 with `G` replaced by `J`
@!X= % Compare original tuple with recovered tuple: are they equal?
JavaScript (ES6), 171 bytes
(x,y)=>(h=x=>parseInt((x^x>>31).toString(2)+(x>>>31),4),h(x)*2+h(y))
x=>(h=x=>parseInt(x.toString(2).replace(/.(?!(..)*$)/g,''),2),i=x=>x<<31>>31^x>>>1,[i(h(x>>>1)),i(h(x))])
Bit twiddling: negative numbers have their bits flipped; each integer is then doubled, and 1 added if it was originally negative; the bits from the integers are then interleaved. The reverse operation deletes alternate bits, divides by 2, and flips all the bits if the value was negative. I could save 3 bytes by limiting myself to 15-bit values instead of 16-bit values.
f=(x,y)=>(h=x=>parseInt((x^x>>31).toString(2)+(x>>>31),4),h(x)*2+h(y))
g=x=>(h=x=>parseInt(x.toString(2).replace(/.(?!(..)*$)/g,''),2),i=x=>x<<31>>31^x>>>1,[i(h(x>>>1)),i(h(x))])
for(i=-100;i<=100;i++)for(j=-100;j<100;j++)if(g(f(i,j))[0]!=i||g(f(i,j))[1]!=j)alert([i,j])Jelly, 50 48 46 45 43 40 39 bytes
Plane to line (18 17 16 bytes):
AḤ_<0$
+RS+
,Ñç/
Try it online!
Line to plane (32 30 29 27 24 23 bytes):
HĊN⁸¡
³R‘R’U⁹¡F³ịÇ
ç1,¢
Try it online!
Explanation:
I'll only explain plane to line, because line to plane is just its opposite.
Firstly, we convert each integer to a natural number, by the function f(x) = 2*|x| - (x<0).
Then, we convert the two natural numbers to another two natural numbers, by the function g(x,y) = (x+y,y).
Finally, we convert them into one natural number, by the function h(x,y) = (x+1)C2 + y