Thread: Encoding multiple values into one variable

Combining the two integer's into a long.

Code:

int a = 12345;
int b = 54321;
long total = (a << 32) + b; //shifting the 32 bits from value 'a' right 32 bits so we can store 'b' in the original slot 'a' was in

To get the value of 'b'

Code:

int value = (int) total; //no need for shift as Integer has 32 bits and will take ending 32 bits of a 64 bit Long

To get the value of 'a'

Code:

int value = (int) (total >> 32); //shifting the bits right 32 discarding the value 'b' (in slot 0-31) and replacing them with value 'a' (in slot 32-64)

Code:

0 (value of a bit) [1 bit]
00000000 (value of a byte) [8 bits]
0000000000000000 (value of a short) [16 bits]
00000000000000000000000000000000 (value of an integer) [32 bits]
0000000000000000000000000000000000000000000000000000000000000000 (value of a long) [64 bits]

This isn't limited to Integer's into longs, you can/could store 4 bytes into an integer if you really wanted to.

Edit: Hope this helps, and whoop whoop x50 posts!

Originally Posted by packersfan84

what are you trying to achieve

I had a hypothesis. If I can have multiple values encoded into one integer or byte, then I could compress trillions and quadrillions of bytes into a couple kilos and have the world's fastest and best compression. Of course, this is pretty much impossible at the moment without knowing the values to encode with.

eg

Code:

public static byte[] compress(byte[] input) {
	byte[] compressed = new byte[1];
	for (int i = 0; i < input.length; i++)
		compressed[0] = (byte) (compressed[0] | (1 << input[i])); // encoding every value into one

	byte[] lengthToBytes = ByteBuffer.allocate(4).putInt(input.length).array();
	compressed = Arrays.copyOf(compressed, lengthToBytes.length + compressed.length);
	for (int i = 0; i < lengthToBytes.length; i++)
		compressed[1 + i] = lengthToBytes[i]; // the first byte is the entire stack of bytes
	return compressed;
}

Now how would I decompress those values if I only know the encoded value and the length of the bytes?

Maybe something like this?

Code:

public static byte[] decompress(byte[] input) {
	int length = ByteBuffer.wrap(Arrays.copyOfRange(input, 1, input.length)).getInt();
	byte[] decompressed = new byte[length]; // encoded value
	byte previous = input[0];
	for (int i = 0; i < length; i++) {
		for (byte b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++) {
			if ((previous & (1 << b)) != 0) {
				decompressed[i] = (byte) (previous &= (1 << b));
				break;
			}
		}
	}
	return decompressed;
}

Originally Posted by Wildskiller

If I can have multiple values encoded into one integer or byte, then I could compress trillions and quadrillions of bytes into a couple kilos and have the world's fastest and best compression.

Yes, you can by bit shifting but keep in mind you can only store 4 bytes in an integer and 8 bits in a byte, you can NOT store more than that. There is always limits to how far you can compress things without data loss. Based on the numbers you are randomly throwing out and the expectation of "the world's fastest and best compression" I think you have little to no idea how data encryption works let alone how to implement it. I recommend reading about lossy and lossless compression from here: [Only registered and activated users can see links. ]

Originally Posted by packersfan84

lol!!!!!!!!!!!!!!!!!!!

shutup you butthole, I've already figured it out ( ° ͜ʖ͡°)╭∩╮. I already know only 32 bits can be stored into an integer, so I can take advantage of this for byte compression and byte pair encoding.

Originally Posted by H3ll Ruler

Yes, you can by bit shifting but keep in mind you can only store 4 bytes in an integer and 8 bits in a byte, you can NOT store more than that. There is always limits to how far you can compress things without data loss. Based on the numbers you are randomly throwing out and the expectation of "the world's fastest and best compression" I think you have little to no idea how data encryption works let alone how to implement it. I recommend reading about lossy and lossless compression from here: [Only registered and activated users can see links. ]

4 bytes, 8 bits per byte, 32 bits per integer. I know this. I don't know why I said "encoded", when I actually wanted to just add or subtract the next byte value from the current byte value and reverse that formulas for byte decompression.

Originally Posted by Wildskiller

when I actually wanted to just add or subtract the next byte value from the current byte value and reverse that formulas for byte decompression.

But then you aren't compressing anything? You need to know the value of a byte to derive the value which is equal to a byte. All you are doing at that point is poor encryption with the key being the bytes following the first one... Well if you figured it out then congrats because apparently don't grasp what you are trying to do here...

Originally Posted by H3ll Ruler

But then you aren't compressing anything? You need to know the value of a byte to derive the value which is equal to a byte. All you are doing at that point is poor encryption with the key being the bytes following the first one... Well if you figured it out then congrats because apparently don't grasp what you are trying to do here...

The key is what holds the byte values. I know what compression is and was just seeing if I could combine it with encryption. I have already said this is impossible, so we might as well leave this be.