The `printf` function takes an argument type, such as `%d` or `%i` for a `signed int`. However, I don&#39;t see anything for a `long` value.

What is the argument for printf that formats a long?

I can never understand how to print `unsigned long` datatype in C.

Suppose `unsigned_foo` is an `unsigned long`, then I try:

* `printf(&quot;%lu\n&quot;, unsigned_foo)`
* `printf(&quot;%du\n&quot;, unsigned_foo)`
* `printf(&quot;%ud\n&quot;, unsigned_foo)`
* `printf(&quot;%ll\n&quot;, unsigned_foo)`
* `printf(&quot;%ld\n&quot;, unsigned_foo)`
* `printf(&quot;%dl\n&quot;, unsigned_foo)`

And all of them print some kind of `-123123123` number instead of `unsigned long` that I have.

How to printf &quot;unsigned long&quot; in C?

I just created sample BB app, which can allow to choose the date.

    DateField curDateFld = new DateField(&quot;Choose Date: &quot;,
      System.currentTimeMillis(), DateField.DATE | DateField.FIELD_LEFT);

After choosing the date, I need to convert that long value to String, so that I can easily store the date value somewhere in database.
I am new to Java and Blackberry development.

    long date = curDateFld.getDate();

How should I convert this long value to String? Also I want to convert back to long from String. I think for that I can use `long l = Long.parseLong(&quot;myStr&quot;);`?


How to convert / cast long to String?

I am transitioning from Java to C++ and have some questions about the `long` data type. In Java, to hold an integer greater than 2&lt;sup&gt;32&lt;/sup&gt;, you would simply write `long x;`. However, in C++, it seems that `long` is both a data type and a modifier. 

There seems to be several ways to use `long`:

    long x;
    long long x;
    long int x;
    long long int x;

Also, it seems there are things such as:

    long double x;

and so on.

What is the difference between all of these various data types, and do they all have the same purpose?

What is the difference between &quot;long&quot;, &quot;long long&quot;, &quot;long int&quot;, and &quot;long long int&quot; in C++?

I keep finding both on here and Google people having troubles going from `long` to `int` and not the other way around. Yet I&#39;m sure I&#39;m not the only one that has run into this scenario before going from `int` to `Long`.

The only other answers I&#39;ve found were &quot;Just set it as Long in the first place&quot; which really doesn&#39;t address the question.

I initially tried casting but I get a &quot;`Cannot cast from int to Long`&quot;

    for (int i = 0; i &lt; myArrayList.size(); ++i ) {
        content = new Content();
        content.setDescription(myArrayList.get(i));
        content.setSequence((Long) i);
        session.save(content);
    }

As you can imagine I&#39;m a little perplexed, I&#39;m stuck using `int` since some content is coming in as an `ArrayList` and the entity for which I&#39;m storing this info requires the sequence number as a Long.

How do I convert from int to Long in Java?

[Primitive Data Types - oracle doc][1] says the range of **`long`** in Java is `-9,223,372,036,854,775,808` to `9,223,372,036,854,775,807`.
But when I do something like this in my eclipse

    long i = 12345678910;

it shows me &quot;`The literal 12345678910 of type int is out of range`&quot; error.

**There are 2 questions.**

1) How do I initialize the **`long`** with the value `12345678910`?

2) Are all numeric literals by default of type **`int`**? 


  [1]: http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

Initialize a long in Java

I think the maximum integer in python is available by calling `sys.maxint`.

What is the maximum `float` or `long` in Python?

What is the maximum float in Python?

How do I convert a `long` to a `byte[]` and back in Java?

I&#39;m trying convert a `long` to a `byte[]` so that I will be able to send the `byte[]` over a TCP connection. On the other side I want to take that `byte[]` and convert it back into a `double`.


How do I convert Long to byte[] and back in java

Does Java have anything to represent infinity for every numerical data type? How is it implemented such that I can do mathematical operations with it?

E.g.

    int myInf = infinity; //However it is done
    myInf + 5; //returns infinity
    myInf*(-1); //returns negative infinity

I have tried using very large numbers, but I want a proper, **easy** solution.

How to implement infinity in Java?

I want to convert `long` to `int`. 

If the value of `long` &gt; `int.MaxValue`, I am happy to let it wrap around. 

What is the best way?



Can I convert long to int?

I found both `long int long` and `int long long` can compile for a variable type. Is there any difference between `long int long`, `int long long` , `long long` and `long long int`?

In general, is the type identical if it has the same number of `long`?

**1 long:**

    long l;
    int long il;
    long int li;

**2 long:**

    long long ll;
    int long long ill;
    long int long lil;
    long long int lli;

Also if above is right, are the following declarations also identical?

    long long* llp;
    int long long* illp;
    long int long* lilp;
    long long int* llip;

Is &quot;long long&quot; = &quot;long long int&quot; = &quot;long int long&quot; = &quot;int long long&quot;?

Random class has a method to generate random int in a given range. For example:

    Random r = new Random(); 
    int x = r.nextInt(100);

This would generate an int number more or equal to 0 and less than 100. I&#39;d like to do exactly the same with long number.

    long y = magicRandomLongGenerator(100);

Random class has only nextLong(), but it doesn&#39;t allow to set range.

Java: random long number in 0 &lt;= x &lt; n range

I have list with long values (for example: 1220227200, 1220832000, 1221436800...) which I downloaded from web service. I must convert it to Dates. Unfortunately this way, for example:

    Date d = new Date(1220227200);

returns 1 Jan 1970. Anyone know another way to convert it correctly?

Converting Long to Date in Java returns 1970

How could i convert data from string to long in C#?

I have data 

    String strValue[i] =&quot;1100.25&quot;;

now i want it in

    long l1;

How could I convert data from string to long in c#

I want to handle the special case where multiplying two numbers together causes an overflow. The code looks something like this:

    int a = 20;
    long b = 30;
    
    // if a or b are big enough, this result will silently overflow
    long c = a * b;

That&#39;s a simplified version. In the real program `a` and `b` are sourced elsewhere at runtime. What I want to achieve is something like this:

    long c;
    if (a * b will overflow) {
        c = Long.MAX_VALUE;
    } else {
        c = a * b;
    }

How do you suggest I best code this?

Update: `a` and `b` are always non-negative in my scenario.


How can I check if multiplying two numbers in Java will cause an overflow?

It appears that when you type in a number in Java, the compiler automatically reads it as an integer, which is why when you type in (long) `6000000000` (not in integer&#39;s range) it will complain that `6000000000` is not an integer.  To correct this, I had to specify `6000000000L`.  I just learned about this specification.

Are there other number specifications like for short, byte, float, double?  It seems like these would be good to have because (I assume) if you could specify the number you&#39;re typing in is a short then java wouldn&#39;t have to cast it - that is an assumption, correct me if I&#39;m wrong.  I would normally search this question myself, but I don&#39;t know what this kind of number specification is even called.

Java&#39;s L number (long) specification

I have 3 very large signed integers.

    long x = long.MaxValue;
    long y = long.MaxValue - 1;
    long z = long.MaxValue - 2;

I want to calculate their truncated average. Expected average value is `long.MaxValue - 1`, which is `9223372036854775806`.

It is impossible to calculate it as:

    long avg = (x + y + z) / 3; // 3074457345618258600

Note: I read all those questions about average of 2 numbers, but I don&#39;t see how that technique can be applied to average of 3 numbers.

It would be very easy with the usage of `BigInteger`, but let&#39;s assume I cannot use it.

    BigInteger bx = new BigInteger(x);
    BigInteger by = new BigInteger(y);
    BigInteger bz = new BigInteger(z);
    BigInteger bavg = (bx + by + bz) / 3; // 9223372036854775806


If I convert to `double`, then, of course, I lose precision:

    double dx = x;
    double dy = y;
    double dz = z;
    double davg = (dx + dy + dz) / 3; // 9223372036854780000

If I convert to `decimal`, it works, but also let&#39;s assume that I cannot use it.

    decimal mx = x;
    decimal my = y;
    decimal mz = z;
    decimal mavg = (mx + my + mz) / 3; // 9223372036854775806

**Question:** Is there a way to calculate the truncated average of 3 very large integers only with the usage of `long` type? Don&#39;t consider that question as C#-specific, just it is easier for me to provide samples in C#.

Average of 3 long integers

This is a basic question but I can&#39;t find an answer.  I&#39;ve looked into floating point arithmetic and a few other topics but nothing has seemed to address this.  I&#39;m sure I just have the wrong terminology.

Basically, I want to take two quantities - completed, and total - and divide them to come up with a percentage (of how much has been completed).  The quantities are `long`s.  Here&#39;s the setup:

    long completed = 25000;
    long total = 50000;

    System.out.println(completed/total);  // Prints 0

I&#39;ve tried reassigning the result to a double - it prints `0.0`.  Where am I going wrong?

Incidentally, the next step is to multiply this result by 100, which I assume should be easy once this small hurdle is stepped over.

BTW not homework here just plain old numskull-ness (and maybe too much coding today).

Division of integers in Java

I am working with data types at the moment in Java, and if I have understood correctly the type `long` accepts a value between the ranges of -9,223,372,036,854,775,808 to +9,223,372,036,854,775,807. Now as you can see below, I have create a `long` variable called `testLong`, although when I insert 9223372036854775807 as the value, I get an error stating:

&gt; The literal 9223372036854775807  of the type int is out of range.

I don&#39;t know why it is referring to the `long` data type as an `int`.

Anyone have any ideas?

Code:

```
char testChar = 01;
byte testByte = -128;
int testInt = -2147483648;
short testShort = -32768;
long testLong = 9223372036854775807;
float testFoat;
double testDouble = 4.940656458412;
boolean testBool = true;
```

The literal xyz of type int is out of range

I have a millisecond timestamp that I need to convert from a string to long. JavaScript has a `parseInt` but not a `parseLong`. So how can I do this?

To expand on my question slightly: given that apparently JavaScript doesn&#39;t have a long type, how can I do simple arithmetic with longs that are initially expressed as strings? E.g subtract one from the other to get a time delta?

How to convert a String to long in javascript?

I&#39;m running Windows 8.1 x64 with Java 7 update 45 x64 (no 32 bit Java installed) on a Surface Pro 2 tablet.

The code below takes 1688ms when the type of i is a long and 109ms when i is an int. Why is long (a 64 bit type) an order of magnitude slower than int on a 64 bit platform with a 64 bit JVM?

My only speculation is that the CPU takes longer to add a 64 bit integer than a 32 bit one, but that seems unlikely. I suspect Haswell doesn&#39;t use ripple-carry adders.

I&#39;m running this in Eclipse Kepler SR1, btw.


    public class Main {
    
        private static long i = Integer.MAX_VALUE;
    
        public static void main(String[] args) {	
            System.out.println(&quot;Starting the loop&quot;);
            long startTime = System.currentTimeMillis();
            while(!decrementAndCheck()){
            }
            long endTime = System.currentTimeMillis();
            System.out.println(&quot;Finished the loop in &quot; + (endTime - startTime) + &quot;ms&quot;);
        }

        private static boolean decrementAndCheck() {
            return --i &lt; 0;
        }

    }


Edit: Here are the results from equivalent C++ code compiled by VS 2013 (below), same system. &lt;del&gt;long: 72265ms int: 74656ms&lt;/del&gt;  Those results were in debug 32 bit mode.

In 64 bit release mode: &lt;del&gt;long: 875ms&lt;/del&gt; long long:  906ms int: 1047ms


This suggests that the result I observed is JVM optimization weirdness rather than CPU limitations.




    #include &quot;stdafx.h&quot;
    #include &quot;iostream&quot;
    #include &quot;windows.h&quot;
    #include &quot;limits.h&quot;

    long long i = INT_MAX;

    using namespace std;


    boolean decrementAndCheck() {
	return --i &lt; 0;
    }


    int _tmain(int argc, _TCHAR* argv[])
    {


	cout &lt;&lt; &quot;Starting the loop&quot; &lt;&lt; endl;

	unsigned long startTime = GetTickCount64();
	while (!decrementAndCheck()){
	}
	unsigned long endTime = GetTickCount64();

	cout &lt;&lt; &quot;Finished the loop in &quot; &lt;&lt; (endTime - startTime) &lt;&lt; &quot;ms&quot; &lt;&lt; endl;



    }


Edit: Just tried this again in Java 8 RTM, no significant change.

Why is long slower than int in x64 Java?

I am trying this code on GNU&#39;s C++ compiler and am unable to understand its behaviour:

    #include &lt;stdio.h&gt;;

    int main()
    {
        int  num1 = 1000000000;
        long num2 = 1000000000;
        long long num3;
        //num3 = 100000000000;
        long long num4 = ~0;

        printf(&quot;%u %u %u&quot;, sizeof(num1), sizeof(num2), sizeof(num3));
        printf(&quot;%d %ld %lld %llu&quot;, num1, num2, num3, num4);
        return 0;
    }

When I uncomment the commented line, the code doesn&#39;t compile and is giving an error:

&gt; error: integer constant is too large for long type

But, if the code is compiled as it is and is executed, it produces values much larger than 10000000000.

Why?


long long in C/C++

Here&#39;s an excerpt from [Sun&#39;s Java tutorials](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html):

&gt; A switch works with the `byte`, `short`, `char`, and `int` primitive data types. It also works with enumerated types (discussed in Classes and Inheritance) and a few special classes that &quot;wrap&quot; certain primitive types: `Character`, `Byte`, `Short`, and `Integer` (discussed in Simple Data Objects).

There must be a good reason why the `long` primitive data type is not allowed.  Anyone know what it is?

Why can&#39;t your switch statement data type be long, Java?

I am new to C/C++, so I have a couple of questions about a basic type: 


a) Can you explain to me the difference between `int64_t` and `long` (`long int`)? 
In my understanding, both are 64 bit integers. Is there any reason to choose one over the other?

b) I tried to look up the definition of `int64_t` on the web, without much success. Is there an authoritative source I need to consult for such questions?

c) For code using `int64_t` to compile, I am currently including `&lt;iostream&gt;`, which doesn&#39;t make much sense to me. Are there other includes that provide a declaration of `int64_t`?

Definition of int64_t

I often see questions relating to `Overflow` errors with [tag:VBA].

My question is why use the `integer` variable declaration instead of just defining all numerical variables (excluding `double` etc.) as `long`?

Unless you&#39;re performing an operation like in a for loop where you can guarantee that the value won&#39;t exceed the 32,767 limit, is there an impact on performance or something else that would dictate not using `long`?

Why Use Integer Instead of Long?

What method would you use to determine if the the bit that represents 2^x is a 1 or 0 ?

Java: Checking if a bit is 0 or 1 in a long

When I call `Math.ceil(5.2)` the return is the `double` `6.0`. My natural inclination was to think that `Math.ceil(double a)` would return a `long`. From the documentation:

&gt; `ceil(double a)`
&gt; 
&gt; Returns the smallest (closest to negative infinity) `double` value
&gt; that is not less than the argument and is equal to a mathematical
&gt; integer.

But why return a `double` rather than a `long` when the result is an integer? I think understanding the reason behind it might help me understand Java a bit better. It also might help me figure out if I&#39;ll get myself into trouble by casting to a `long`, e.g. is

`long b = (long)Math.ceil(a);`

always what I think it should be? I fear there could be some boundary cases that are problematic.


Why does Math.ceil return a double?

How can you display a long string, website address, word or set of symbols with automatic line breaks to keep a div width? I guess a wordwrap of sorts. Usually adding a space works but is there a CSS solution such as word-wrap?

For example it (very nastily) overlaps divs, forces horizontal scrolling etc. 
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww 

What can I add to the above string to fit it neatly within a few lines in a div or within the browser window?

wordwrap a very long string

I have a Python version 3.3.0 and I am not sure why it does not let me do long for b and m here...
I tried to look up the answers on here and but nothing helped...thanks

im getting an error saying

    NameError: global name &#39;long&#39; is not defined


    power = long(b) % long(m)
    
    

NameError: global name &#39;long&#39; is not defined

I&#39;m very new to dealing with bits and have got stuck on the following warning when compiling:

&gt;      7: warning: left shift count &gt;= width of type

My line 7 looks like this

    unsigned long int x = 1 &lt;&lt; 32;

This would make sense if the size of `long` on my system was 32 bits. However, `sizeof(long)` returns `8` and `CHAR_BIT` is defined as `8` suggesting that long should be 8x8 = 64 bits long.

What am I missing here? Are `sizeof` and `CHAR_BIT` inaccurate or have I misunderstood something fundamental?

warning: left shift count &gt;= width of type

I was looking at some of the solutions in Google Code Jam and some people used this things that I had never seen before. For example,

    2LL*r+1LL

What does 2LL and 1LL mean?

Their includes look like this:

    #include &lt;math.h&gt;
    #include &lt;algorithm&gt;
    #define _USE_MATH_DEFINES

or 

    #include &lt;cmath&gt;



What is 1LL or 2LL in C and C++?

As I&#39;ve learned recently, a `long` in C/C++ is the same length as an `int`.  To put it simply, why?  It seems almost pointless to even include the datatype in the language.  Does it have any uses specific to it that an `int` doesn&#39;t have?  I know we can declare a 64-bit `int` like so:

    long long x = 0;

But why does the language choose to do it this way, rather than just making a `long` well...longer than an `int`?  Other languages such as C# do this, so why not C/C++?

Long Vs. Int C/C++ - What&#39;s The Point?

how do you convert a string into a long.

for int you

    int i = 3423;
    String str;
    str = str.valueOf(i);

so how do you go the other way but with long.

    long lg;
    String Str = &quot;1333073704000&quot;
    lg = lg.valueOf(Str);

How to convert string to long

Is it OK to compare an int and a long in Java...

    long l = 800L
    int i = 4

    if (i &lt; l) {
     // i is less than l
    }

Is it OK to compare an int and a long in Java

I understand that both `java.lang.Long` and `java.math.BigInteger `can hold very large natural numbers.

I also know Long&#39;s max value, but what is the max value for BigInteger?

And aside from capacity, would BigInteger ever perform better when working with generally large integers that still fall in Long&#39;s range?

Question
--------

Is the only consideration: is my value too large for Long?

Long vs BigInteger

I&#39;m doing a program that aproximate PI and i&#39;m trying to use long long, but it isn&#39;t working.
Here is the code

    #include&lt;stdio.h&gt;
    #include&lt;math.h&gt;
    typedef long long num;
    main(){
        num pi;
        pi=0;
        num e, n;
        scanf(&quot;%d&quot;, &amp;n);
        for(e=0; 1;e++){
          pi += ((pow((-1.0),e))/(2.0*e+1.0));
          if(e%n==0)
            printf(&quot;%15lld -&gt; %1.16lld\n&quot;,e, 4*pi);
          //printf(&quot;%lld\n&quot;,4*pi);
        }
    }



How to printf long long

In a recent homework assignment I&#39;ve been told to use `long` variable to store a result, since it may be a big number.

I decided to check will it really matter for me, on my system (intel core i5/64-bit windows 7/gnu gcc compiler) and found out that the following code:

    printf(&quot;sizeof(char) =&gt; %d\n&quot;, sizeof(char));
    printf(&quot;sizeof(short) =&gt; %d\n&quot;, sizeof(short));
    printf(&quot;sizeof(short int) =&gt; %d\n&quot;, sizeof(short int));
    printf(&quot;sizeof(int) =&gt; %d\n&quot;, sizeof(int));
    printf(&quot;sizeof(long) =&gt; %d\n&quot;, sizeof(long));
    printf(&quot;sizeof(long int) =&gt; %d\n&quot;, sizeof(long int));
    printf(&quot;sizeof(long long) =&gt; %d\n&quot;, sizeof(long long));
    printf(&quot;sizeof(long long int) =&gt; %d\n&quot;, sizeof(long long int));

produces the following output:

    sizeof(char) =&gt; 1
    sizeof(short) =&gt; 2
    sizeof(short int) =&gt; 2
    sizeof(int) =&gt; 4
    sizeof(long) =&gt; 4
    sizeof(long int) =&gt; 4
    sizeof(long long) =&gt; 8
    sizeof(long long int) =&gt; 8

In other words, on my system, `int` and `long` are the same, and whatever will be too big for `int` to hold, will be too big for `long` to hold as well.

The homework assignment itself is not the issue here. I wonder how, on a system where `int &lt; long`, should I assign an `int` to long?

I&#39;m aware to the fact that [there](https://stackoverflow.com/questions/12501331/how-does-long-to-int-cast-work-in-java) [are](https://stackoverflow.com/questions/1590831/safely-casting-long-to-int-in-java) [numerous](https://stackoverflow.com/questions/1161887/what-happens-if-i-cast-a-double-to-an-int-but-the-value-of-the-double-is-out-of) [closely](https://stackoverflow.com/questions/2711522/what-happens-if-i-assign-a-negative-value-to-an-unsigned-variable) [related](https://stackoverflow.com/questions/7977265/what-happens-at-background-when-convert-int-to-float) questions on this subject, but I feel that the answers within these do not provide me with the complete understanding of what will or may happen in the process.

Basically I&#39;m trying to figure out the following:

 1. Should I cast `long` to `int` before the assignment, or &lt;del&gt;since `long`
    is not a different data type, but merely a modifier,&lt;/del&gt; it will be
    considered unharmful to assign directly?
 2. What happens on systems where `long &gt; int`? Will the result be
    undefined (or unpredictable) or it will cause the extra parts of the
    variable to be omitted?
 3. How does the casting from `long` to `int` works in C?
 4. How does the assignment from `long` to `int` works in C when I don&#39;t
    use casting?

What happens when I assign long int to int in C?

I want to convert a hex string to long in java.

I have tried with general conversion. 

    String s = &quot;4d0d08ada45f9dde1e99cad9&quot;;
    long l = Long.valueOf(s).longValue();
    System.out.println(l);
    String ls = Long.toString(l);

But I am getting this error message:

    java.lang.NumberFormatException: For input string: &quot;4d0d08ada45f9dde1e99cad9&quot;

Is there any way to convert String to long in java? Or am i trying which is not really possible!!

Thanks!

How to convert a hexadecimal string to long in java?

I&#39;m trying to implement RC4 and DH key exchange in python. Problem is that I have no idea about how to convert the python long/int from the key exchange to the byte array I need for the RC4 implementation. Is there a simple way to convert a long to the required length byte array?

**Update**: forgot to mention that the numbers I&#39;m dealing with are 768 bit unsigned integers.

Convert python long/int to fixed size byte array

By my reading of the C++ Standard, I have always understood that the sizes of the integral fundamental types in C++ were as follows:

    sizeof(char) &lt;= sizeof(short int) &lt;= sizeof(int) &lt;= sizeof(long int)

I deduced this from 3.9.1/2:

&gt; 2. There are four signed integer types: “signed char”, “short int”,
&gt; “int”, and “long int.” In this list,
&gt; each type provides at least as much
&gt; storage as those preceding it in the
&gt; list. Plain ints have the natural size
&gt; suggested by the architecture of the
&gt; execution environment

Further, the size of `char` is described by 3.9.1/ as being:

 &gt; 1. [...] large enough to store any member of the implementation’s basic character set.

1.7/1 defines this in more concrete terms:

 &gt; 1. The fundamental storage unit in the C + + memory model is the byte. A byte is at least large enough to contain any member of the basic execution character set and is composed of a contiguous sequence of bits, the number of which is implementation-defined.

This leads me to the following conclusion:

    1 == sizeof(char) &lt;= sizeof(short int) &lt;= sizeof(int) &lt;= sizeof(long int)

where `sizeof` tells us how many bytes the type is.  Furthermore, it is implementation-defined how many bits are in a byte.  Most of us are probably used to dealing with 8-bit bytes, but the Standard says there are `n` bits in a byte.

----------
In [this post][1], Alf P. Steinbach says: 

&gt; long is guaranteed (at least) 32 bits. 

This flies in the face of everything I understand the size of the fundamental types to be in C++ according to the Standard.  Normally I would just discount this statement as a beginner being wrong, but since this was Alf I decided it was worth investigating further.

So, what say you?  Is a long guaranteed by the standard to be at least 32 bits?  If so, please be specific as to how this guarantee is made.  I just don&#39;t see it.

1. The C++ Standard specifically says that in order to know C++ you must know C (1.2/1) &lt;sup&gt;1&lt;/sup&gt;

2. The C++ Standard implicitly defines the minimum limit on the values a `long` can accommodate to be `LONG_MIN`-`LONG_MAX` &lt;sup&gt;2&lt;/sup&gt;

So no matter how big a `long` is, it has to be big enough to hold LONG_MIN to LONG_MAX.

But Alf and others are *specific* that a long must be at least 32 bits.  This is what I&#39;m trying to establish.  The C++ Standard is explicit that the number of bits in a byte are not specified (it could be 4, 8, 16, 42)  So how is the connection made from being able to accommodate the numbers `LONG_MIN-LONG_MAX` to being at least 32 bits?


----------


(1) 1.2/1: The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.

 - ISO/IEC 2382 (all parts), Information technology – Vocabulary 
 - ISO/IEC 9899:1999, Programming languages – C
 - ISO/IEC 10646-1:2000, Information technology – Universal Multiple-Octet Coded Character Set (UCS) – Part 1: Architecture and Basic Multilingual Plane

(2) Defined in `&lt;climits&gt;` as:

    LONG_MIN -2147483647 // -(2^31 - 1)
    LONG_MAX +2147483647 //   2^31 - 1

  [1]: https://stackoverflow.com/questions/4329277/whats-the-point-of-long-data-type/4329349#4329349


Is `long` guaranteed to be at least 32 bits?

How can I get a long number bigger than Long.MAX_VALUE?

I want this method to return `true`:

    boolean isBiggerThanMaxLong(long val) {
        return (val &gt; Long.MAX_VALUE);
    }

A long bigger than Long.MAX_VALUE

How do I check a Long value for null in Java?

Will this work? 


    if ( longValue == null) { return blah; }

How to check a Long for null in java

I want to change a values in byte array to put a long timestamp value in in the MSBs. Can someone tell me whats the best way to do it. I do not want to insert values bit-by-bit which I believe is very inefficient. 

    
    long time = System.currentTimeMillis();
    Long timeStamp = new Long(time);
    byte[] bArray = new byte[128];
    
What I want is something like:

    byte[0-63] = timeStamp.byteValue(); 

Is something like this possible . What is the best way to edit/insert values in this byte array. since byte is a primitive I dont think there are some direct implementations I can make use of?

Edit:  
It seems that `System.currentTimeMillis()` is faster than `Calendar.getTimeInMillis()`, so replacing the above code by it.Please correct me if wrong.

Convert long to byte array and add it to another array

I am running the exact same code on both windows and mac, with python 3.5 64 bit. 

On windows, it looks like this:

    &gt;&gt;&gt; import numpy as np
    &gt;&gt;&gt; preds = np.zeros((1, 3), dtype=int)
    &gt;&gt;&gt; p = [6802256107, 5017549029, 3745804973]
    &gt;&gt;&gt; preds[0] = p
    Traceback (most recent call last):
      File &quot;&lt;pyshell#13&gt;&quot;, line 1, in &lt;module&gt;
        preds[0] = p
    OverflowError: Python int too large to convert to C long
    
However, this code works fine on my mac. Could anyone help explain why or give a solution for the code on windows? Thanks so much!

All Long Integer Solutions on Gang of Coders

Total of 44 Long Integer Solutions