Java Equivalent of Unsigned Long Long

Java equivalent of unsigned long long?

I don't believe so. Once you want to go bigger than a signed long, I think BigInteger is the only (out of the box) way to go.

What is the equivalent of unsigned long in java

Short answer, there's no unsigned data type in java. long in C is 32-bit on 32-bit systems, but java's long is 64-bit, so you can use that for replacement (at least it would solve the overflow problem). If you need even wider integers, use BigInteger class.

Java equivalent of unsigned long long is not BigInteger?

unsigned long long is a limited-length integer format (probably 64bit or more). That means that it can hold no value larger than 2⁶⁴-1.

A BigInteger is an arbitrary-length integer format. That means that the size of the number stored in a BigInteger is effectively limited only by the available memory (and some JVM restrictions like the size of an array, but those are pretty big).

Somewhere in your calculation in the C program the unsigned long long probably overflows and you get a cut-off result.

That doesn't happen with BigInteger (it never silently overflows), it will just give the exact result.

You can emulate an overflow by creating a BigInteger that holds the desired bit mask (64 set bits) and using myValue.and(MASK) to get the "overflown" result.

You'd have to do that at every step where an overflow could occur, 'though. And it would certainly be slower than the C code.

How to convert 'unsigned long' to string in java

You need to use BigInteger unfortunately, or write your own routine.

Here is an Unsigned class which helps with these workarounds

private static final BigInteger BI_2_64 = BigInteger.ONE.shiftLeft(64);

public static String asString(long l) {
    return l >= 0 ? String.valueOf(l) : toBigInteger(l).toString();
}

public static BigInteger toBigInteger(long l) {
    final BigInteger bi = BigInteger.valueOf(l);
    return l >= 0 ? bi : bi.add(BI_2_64);
}

how to declare a long long array in Java?

I do not know a type called "long long".

Are you sure the code you read was written in Java? Maybe it was a JNI routine that was called into?

it isn't also listed here: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

Declaring an unsigned int in Java

Java does not have a datatype for unsigned integers.

You can define a long instead of an int if you need to store large values.

You can also use a signed integer as if it were unsigned. The benefit of two's complement representation is that most operations (such as addition, subtraction, multiplication, and left shift) are identical on a binary level for signed and unsigned integers. A few operations (division, right shift, comparison, and casting), however, are different. As of Java SE 8, new methods in the Integer class allow you to fully use the int data type to perform unsigned arithmetic:

In Java SE 8 and later, you can use the int data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 2^32-1. Use the Integer class to use int data type as an unsigned integer. Static methods like compareUnsigned, divideUnsigned etc have been added to the Integer class to support the arithmetic operations for unsigned integers.

Note that int variables are still signed when declared but unsigned arithmetic is now possible by using those methods in the Integer class.

How to convert unsigned long long int into Java?

This looks trivial to rewrite with BigInteger. Note that argv[0] in C++ is the program name. Java does not follow that convention. So it might look something like,

BigInteger[] gn = { BigInteger.ZERO, BigInteger.ZERO, BigInteger.ONE };
int n = Integer.parseInt(args[0]);
for (int i = 3; i <= n; i++) {
    BigInteger tmp = BigInteger.ZERO;
    for (int j = 0; j < 3; j++) {
        tmp = tmp.add(gn[j]);
    }
    gn[0] = gn[1];
    gn[1] = gn[2];
    gn[2] = tmp;
}
System.out.println(gn[Math.min(n, 2)]);

Java: signed long to unsigned long string

Here is a solution using BigInteger:

/** the constant 2^64 */
private static final BigInteger TWO_64 = BigInteger.ONE.shiftLeft(64);

public String asUnsignedDecimalString(long l) {
   BigInteger b = BigInteger.valueOf(l);
   if(b.signum() < 0) {
      b = b.add(TWO_64);
   }
   return b.toString();
}

This works since the unsigned value of a (signed) number in two-s complement is just 2^{(number of bits)} more than the signed value, and Java's long has 64 bits.

And BigInteger has this nice toString() method which we can use here.

Best way to convert a signed integer to an unsigned long?

Something like this?

int x = -1;
long y = x & 0x00000000ffffffffL;

Or am I missing something?

public static long getUnsignedInt(int x) {
    return x & 0x00000000ffffffffL;
}