No, you can&#39;t, at least with current version of NumPy. A `nan` is a special value for float arrays **only**.

There are talks about introducing a special bit that would allow non-float arrays to store what in practice would correspond to a `nan`, but so far (2012/10), it&#39;s only talks.

In the meantime, you may want to consider the [`numpy.ma`](http://docs.scipy.org/doc/numpy/reference/maskedarray.html) package: instead of picking an invalid integer like -99999, you could use the special `numpy.ma.masked` value to represent an invalid value. 

    a = np.ma.array([1,2,3,4,5], dtype=int)
    a[1] = np.ma.masked
    masked_array(data = [1 -- 3 4 5],
                 mask = [False  True False False False],
           fill_value = 999999)

A nan is a floating point only thing, there is no representation of it in the integers, so no :)

Pick an invalid value, like -99999

I am using `groovy` to create a file like `&quot;../A/B/file.txt&quot;`. To do this, I have created a `service` and pass the `file path` to be created as an `argument`. This service is then used by a `Job`. The `Job` will do the logic in creating the file in the specified directory. I have manually created the &quot;A&quot; directory.

How will I create the &quot;B&quot; directory and the file.txt inside the &quot;A&quot; directory through codes to create it automatically?

I need also to check if directories &quot;B&quot; and &quot;A&quot; exists before creating the file.

How to check if a directory containing a file exist?

&gt; **Possible Duplicate:**  
&gt; [How do JavaScript closures work?](https://stackoverflow.com/questions/111102/how-do-javascript-closures-work)  

&lt;!-- End of automatically inserted text --&gt;

I was playing around with the [Google Closure Compiler][1], putting in random code to see what it would do.

It rewrote one of my functions to look something like this:

    (function(msg) { console.log(msg); })(&quot;Hello World!&quot;);​​​​​​​

Where it appears that `&quot;Hello World&quot;` is the argument passed as `msg` to the anonymous function preceding it. I was looking at it for a moment, and had thought that I had seen something similar in jQuery plugins that look something like:

    (function( $ ) {
      ...
    })(jQuery); 

Which now makes more sense to me, in the scope of conflicts with `$`. But what is the primary reason or purpose for passing arguments into an anonymous function like this? Why wouldn&#39;t you simply define the arguments as variables within the function? Is there any performance or flexibility advantage to writing functions like this?

  [1]: http://closure-compiler.appspot.com/home

What is the purpose of passing arguments to anonymous functions in this manner?

Is there a way to store NaN in a Numpy array of integers?
I get: 

    a=np.array([1],dtype=long)
    a[0]=np.nan
    
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    ValueError: cannot convert float NaN to integer

Numpy integer nan

Is there a way to store NaN in a Numpy array of integers?
I get:
<pre><code class="hljs language-sql">a=np.array([1],dtype=long)
a[0]=np.nan

Traceback (most recent call last):
 File "&#x3C;stdin>", line 1, in &#x3C;module>
ValueError: cannot convert float NaN to integer
</code></pre>

I was writing some lambda functions and couldn&#39;t figure this out. Is there a way to have something like `lambda x: x if (x&lt;3)` in python? As `lambda a,b: a if (a &gt; b) else b` works ok. So far `lambda x: x &lt; 3 and x or None` seems to be the closest i have found.

Python lambda with if but without else

How can I turn the minor ticks only on y axis on a linear vs linear plot?

When I use the function `minor_ticks_on` to turn minor ticks on, they appear on both x and y axis.

how to turn on minor ticks only on y axis matplotlib

When I attempt to use a static method from within the body of the class, and define the static method using the built-in `staticmethod` function as a decorator, like this:

    class Klass(object):

        @staticmethod  # use as decorator
        def _stat_func():
            return 42

        _ANS = _stat_func()  # call the staticmethod

        def method(self):
            ret = Klass._stat_func() + Klass._ANS
            return ret

I get the following error:

&lt;!-- language: lang-none --&gt;

    Traceback (most recent call last):
      File &quot;call_staticmethod.py&quot;, line 1, in &lt;module&gt;
        class Klass(object): 
      File &quot;call_staticmethod.py&quot;, line 7, in Klass
        _ANS = _stat_func() 
      TypeError: &#39;staticmethod&#39; object is not callable

*I understand why this is happening (descriptor binding)*, and can work around it by manually converting `_stat_func()` into a staticmethod after its last use, like so:

    class Klass(object):

        def _stat_func():
            return 42

        _ANS = _stat_func()  # use the non-staticmethod version

        _stat_func = staticmethod(_stat_func)  # convert function to a static method

        def method(self):
            ret = Klass._stat_func() + Klass._ANS
            return ret

So my question is:

&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;**Are there cleaner or more &quot;Pythonic&quot; ways to accomplish this?**


Calling class staticmethod within the class body?

This simple code that simply tries to replace semicolons (at i-specified postions) by colons does not work:

    for i in range(0,len(line)):
         if (line[i]==&quot;;&quot; and i in rightindexarray):
             line[i]=&quot;:&quot;

It gives the error 

    line[i]=&quot;:&quot;
    TypeError: &#39;str&#39; object does not support item assignment

How can I work around this to replace the semicolons by colons? Using replace does not work as that function takes no index- there might be some semicolons I do not want to replace.

**Example**

In the string I might have any number of semicolons, eg &quot;Hei der! ; Hello there ;!;&quot;

I know which ones I want to replace (I have their index in the string). Using replace does not work as I&#39;m not able to use an index with it.

Replacing instances of a character in a string

In my application I load text files that are structured as follows:

- First non numeric column (ID)
- A number of non-numeric columns (strings)
- A number of numeric columns (floats)

The number of the non-numeric columns is variable. Currently I load the data into a DataFrame like this:

    source = pandas.read_table(inputfile, index_col=0)

I would like to drop all non-numeric columns in one fell swoop, without knowing their names or indices, since this could be doable reading their dtype. Is this possible with pandas or do I have to cook up something on my own?

Drop non-numeric columns from a pandas DataFrame

I am trying to do the following but with numpy arrays:

    x = [(0.1, 1.), (0.1, 2.), (0.1, 3.), (0.1, 4.), (0.1, 5.)]
    normal_result = zip(*x)

This should give a result of:

    normal_result = [(0.1, 0.1, 0.1, 0.1, 0.1), (1., 2., 3., 4., 5.)]

But if the input vector is a numpy array:

    y = np.array(x)
    numpy_result = zip(*y)
    print type(numpy_result)

It (expectedly) returns a:

    &lt;type &#39;list&#39;&gt;

The issue is that I will need to transform the result back into a numpy array after this.

**What I would like to know is what is if there is an efficient numpy function that will avoid these back-and-forth transformations?**

What is the equivalent of &quot;zip()&quot; in Python&#39;s numpy?

I&#39;m reading a CSV with float numbers like this:

    Bob,0.085
    Alice,0.005

And import into a dataframe, and write this dataframe to a new place

    df = pd.read_csv(orig)
    df.to_csv(pandasfile)

Now this `pandasfile` has:

    Bob,0.085000000000000006
    Alice,0.0050000000000000001


What happen? maybe I have to cast to a different type like float32 or something? 

Im using __pandas 0.9.0__ and __numpy 1.6.2__.




float64 with pandas to_csv

Numpy, scipy, matplotlib, and pylab are common terms among they who use python for scientific computation.

I just learn a bit about pylab, and I got confused.
Whenever I want to import numpy, I can always do:

    import numpy as np

I just consider, that once I do

    from pylab import *

the numpy will be imported as well (with `np` alias). So basically the second one does more things compared to the first one.

There are few things I want to ask:

 1. Is it right that pylab is just a wrapper for numpy, scipy and matplotlib?
 2. As np is the numpy alias in pylab, what is the scipy and matplotlib alias in pylab? (as far as I know, plt is alias of matplotlib.pyplot, but I don&#39;t know the alias for the matplotlib itself)
 

Confusion between numpy, scipy, matplotlib and pylab

I have to count all the values in a matrix (2-d array) that are less than 200.

The code I wrote down for this is:

    za=0   
	p31 = numpy.asarray(o31)   
	for i in range(o31.size[0]):   
		for j in range(o32.size[1]):   
			if p31[i,j]&lt;200:   
				za=za+1   
	print za

`o31` is an image and I am converting it into a matrix and then finding the values.

Is there a simpler way to do this?

Count all values in a matrix less than a value

`scipy.spatial.distance.pdist` returns a condensed distance matrix. From [the documentation][1]:

&gt; Returns a condensed distance matrix Y. For each  and  (where ), the metric dist(u=X[i], v=X[j]) is computed and stored in entry ij.

I thought `ij` meant `i*j`. But I think I might be wrong. Consider

&lt;!-- language: lang-py --&gt;

    X = array([[1,2], [1,2], [3,4]])
    dist_matrix = pdist(X)

then the documentation says that `dist(X[0], X[2])` should be `dist_matrix[0*2]`. However, `dist_matrix[0*2]` is 0 -- not 2.8 as it should be. 

What&#39;s the formula I should use to access the similarity of a two vectors, given `i` and `j`?


  [1]: http://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html

How does condensed distance matrix work? (pdist)

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?

In a loop in C++, I usually encounter situations to use `++` or `+=1`, but I can&#39;t tell their difference. For instance, if I have an integer

    int num = 0;

and then in a loop I do:

    num ++;

or
 
    num += 1;

they both increase the value of `num`, but what is their difference? I doubt `num++` could work faster than `num+=1`, but how? Is this difference subtle enough to be ignored? 

What is the difference between &quot;++&quot; and &quot;+= 1 &quot; operators?

I want to define a function that takes an `unsigned int` as argument and returns an `int` congruent modulo UINT_MAX+1 to the argument.

A first attempt might look like this:

    int unsigned_to_signed(unsigned n)
    {
        return static_cast&lt;int&gt;(n);
    }

But as any language lawyer knows, casting from unsigned to signed for values larger than INT_MAX is implementation-defined.

I want to implement this such that (a) it only relies on behavior mandated by the spec; and (b) it compiles into a no-op on any modern machine and optimizing compiler.

As for bizarre machines...  If there is no signed int congruent modulo UINT_MAX+1 to the unsigned int, let&#39;s say I want to throw an exception.  If there is more than one (I am not sure this is possible), let&#39;s say I want the largest one.

OK, second attempt:

    int unsigned_to_signed(unsigned n)
    {
        int int_n = static_cast&lt;int&gt;(n);

        if (n == static_cast&lt;unsigned&gt;(int_n))
            return int_n;

        // else do something long and complicated
    }

I do not much care about the efficiency when I am not on a typical twos-complement system, since in my humble opinion that is unlikely.  And if my code becomes a bottleneck on the omnipresent sign-magnitude systems of 2050, well, I bet someone can figure that out and optimize it then.

Now, this second attempt is pretty close to what I want.  Although the cast to `int` is implementation-defined for some inputs, the cast back to `unsigned` is guaranteed by the standard to preserve the value modulo UINT_MAX+1.  So the conditional does check exactly what I want, and it will compile into nothing on any system I am likely to encounter.

However...  I am still casting to `int` without first checking whether it will invoke implementation-defined behavior.  On some hypothetical system in 2050 it could do who-knows-what.  So let&#39;s say I want to avoid that.

Question:  What should my &quot;third attempt&quot; look like?

To recap, I want to:

 - Cast from unsigned int to signed int
 - Preserve the value mod UINT_MAX+1
 - Invoke only standard-mandated behavior
 - Compile into a no-op on a typical twos-complement machine with optimizing compiler

[Update]

Let me give an example to show why this is not a trivial question.

Consider a hypothetical C++ implementation with the following properties:

 - `sizeof(int)` equals 4
 - `sizeof(unsigned)` equals 4
 - `INT_MAX` equals 32767
 - `INT_MIN` equals -2&lt;sup&gt;32&lt;/sup&gt; + 32768
 - `UINT_MAX` equals 2&lt;sup&gt;32&lt;/sup&gt; - 1
 -  Arithmetic on `int` is modulo 2&lt;sup&gt;32&lt;/sup&gt; (into the range `INT_MIN` through `INT_MAX`)
 - `std::numeric_limits&lt;int&gt;::is_modulo` is true
 - Casting unsigned `n` to int preserves the value for 0 &lt;= n &lt;= 32767 and yields _zero_ otherwise

On this hypothetical implementation, there is exactly one `int` value congruent (mod UINT_MAX+1) to each `unsigned` value.  So my question would be well-defined.

I claim that this hypothetical C++ implementation fully conforms to the C++98, C++03, and C++11 specifications.  I admit I have not memorized every word of all of them...  But I believe I have read the relevant sections carefully.  So if you want me to accept your answer, you either must (a) cite a spec that rules out this hypothetical implementation or (b) handle it correctly.

Indeed, a correct answer must handle _every_ hypothetical implementation permitted by the standard. That is what &quot;invoke only standard-mandated behavior&quot; means, by definition.

Incidentally, note that `std::numeric_limits&lt;int&gt;::is_modulo` is utterly useless here for multiple reasons.  For one thing, it can be `true` even if unsigned-to-signed casts do not work for large unsigned values.  For another, it can be `true` even on one&#39;s-complement or sign-magnitude systems, if arithmetic is simply modulo the entire integer range.  And so on.  If your answer depends on `is_modulo`, it&#39;s wrong.

[Update 2]

[hvd&#39;s answer][1] taught me something:  My hypothetical C++ implementation for integers is _not_ permitted by modern C.  The C99 and C11 standards are very specific about the representation of signed integers; indeed, they only permit twos-complement, ones-complement, and sign-magnitude (section 6.2.6.2 paragraph (2); ).

But C++ is not C.  As it turns out, this fact lies at the very heart of my question.

The original C++98 standard was based on the much older C89, which says (section 3.1.2.5):

&gt; For each of the signed integer types, there is a corresponding (but
&gt; different) unsigned integer type (designated with the keyword
&gt; unsigned)  that uses the same amount of storage (including sign
&gt; information) and has the same alignment requirements.  The range of
&gt; nonnegative values of a signed integer type is a subrange of the
&gt; corresponding unsigned integer type, and the representation of the
&gt; same value in each type is the same.

C89 says nothing about only having one sign bit or only allowing twos-complement/ones-complement/sign-magnitude.

The C++98 standard adopted this language nearly verbatim (section 3.9.1 paragraph (3)):

&gt; For each of the signed integer types, there exists a corresponding
&gt; (but different) *unsigned integer type*: &quot;`unsigned char`&quot;, &quot;`unsigned
&gt; short int`&quot;, &quot;`unsigned int`&quot;, and &quot;`unsigned long int`&quot;, each of
&gt; which occupies the same amount of storage and has the same alignment
&gt; requirements (3.9) as the corresponding signed integer type ; that
&gt; is, each *signed integer* type has the same object representation as
&gt; its corresponding *unsigned integer* type. The range of nonnegative
&gt; values of a signed integer type is a subrange of the corresponding
&gt; unsigned integer type, and the value representation of each
&gt; corresponding signed/unsigned type shall be the same.

The C++03 standard uses essentially identical language, as does C++11.

No standard C++ spec constrains its signed integer representations to any C spec, as far as I can tell.  And there is nothing mandating a single sign bit or anything of the kind.  All it says is that _non-negative_ signed integers must be a subrange of the corresponding unsigned.

So, again I claim that INT_MAX=32767 with INT_MIN=-2&lt;sup&gt;32&lt;/sup&gt;+32768 is permitted.  If your answer assumes otherwise, it is incorrect unless you cite a **C++** standard proving me wrong.

  [1]: https://stackoverflow.com/a/13208789/768469

Efficient unsigned-to-signed cast avoiding implementation-defined behavior

Assuming you&#39;re using a compiler that supports C99 (or even just stdint.h), is there any reason not to use fixed-width integer types such as uint8_t?

One reason that I&#39;m aware of is that it makes much more sense to use `char`s when dealing with characters instead of using `(u)int8_t`s, as mentioned in [this question][1].

But if you are planning on storing a number, when would you want to use a type that you don&#39;t know how big it is? I.e. In what situation would you want to store a number in an `unsigned short` without knowing if it is 8, 16, or even 32 bits, instead of using a `uint16t`?

Following on from this, is it considered better practice to use fixed-width integers, or to use the normal integer types and just never assume anything and use `sizeof` wherever you need to know how many bytes they are using?


  [1]: https://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char

Is there any reason not to use fixed width integer types (e.g. uint8_t)?

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 have a Pandas Dataframe as below:

          itm Date                  Amount 
    67    420 2012-09-30 00:00:00   65211
    68    421 2012-09-09 00:00:00   29424
    69    421 2012-09-16 00:00:00   29877
    70    421 2012-09-23 00:00:00   30990
    71    421 2012-09-30 00:00:00   61303
    72    485 2012-09-09 00:00:00   71781
    73    485 2012-09-16 00:00:00     NaN
    74    485 2012-09-23 00:00:00   11072
    75    485 2012-09-30 00:00:00  113702
    76    489 2012-09-09 00:00:00   64731
    77    489 2012-09-16 00:00:00     NaN

When I try to apply a function to the Amount column, I get the following error:

    ValueError: cannot convert float NaN to integer

I have tried applying a function using .isnan from the Math Module
I have tried the pandas .replace attribute
I tried the .sparse data attribute from pandas 0.9
I have also tried if NaN == NaN statement in a function.
I have also looked at this article https://stackoverflow.com/questions/8161836/how-do-i-replace-na-values-with-zeros-in-r whilst looking at some other articles. 
All the methods I have tried have not worked or do not recognise NaN.
Any Hints or solutions would be appreciated. 

How to replace NaN values by Zeroes in a column of a Pandas Dataframe?

I have this `DataFrame` and want only the records whose `EPS` column is not `NaN`:

    &gt;&gt;&gt; df
                     STK_ID  EPS  cash
    STK_ID RPT_Date                   
    601166 20111231  601166  NaN   NaN
    600036 20111231  600036  NaN    12
    600016 20111231  600016  4.3   NaN
    601009 20111231  601009  NaN   NaN
    601939 20111231  601939  2.5   NaN
    000001 20111231  000001  NaN   NaN

...i.e. something like `df.drop(....)` to get this resulting dataframe:

                      STK_ID  EPS  cash
    STK_ID RPT_Date                   
    600016 20111231  600016  4.3   NaN
    601939 20111231  601939  2.5   NaN

How do I do that?

How to drop rows of Pandas DataFrame whose value in a certain column is NaN

I have created a Pandas DataFrame

    df = DataFrame(index=[&#39;A&#39;,&#39;B&#39;,&#39;C&#39;], columns=[&#39;x&#39;,&#39;y&#39;])

and have got this
&lt;pre&gt;
    x    y
A  NaN  NaN
B  NaN  NaN
C  NaN  NaN
&lt;/pre&gt;

Now, I would like to assign a value to particular cell, for example to row `C` and column `x`.
I would expect to get this result:
&lt;pre&gt;
    x    y
A  NaN  NaN
B  NaN  NaN
C  10  NaN
&lt;/pre&gt;

with this code:

    df.xs(&#39;C&#39;)[&#39;x&#39;] = 10

However, the contents of `df` has not changed. The dataframe contains yet again only `NaN`s. 

Any suggestions?

Set value for particular cell in pandas DataFrame using index

I have a dataframe with ~300K rows and ~40 columns.
I want to find out if any rows contain null values - and put these &#39;null&#39;-rows into a separate dataframe so that I could explore them easily.

I can create a mask explicitly:

    mask = False
    for col in df.columns: 
        mask = mask | df[col].isnull()
    dfnulls = df[mask]

Or I can do something like:

    df.ix[df.index[(df.T == np.nan).sum() &gt; 1]]

Is there a more elegant way of doing it (locating rows with nulls in them)?



How to select rows with one or more nulls from a pandas DataFrame without listing columns explicitly?

Is this possible to assign a `NaN` to a `double` or `float` in C/C++? Like in JavaScript you do: `a = NaN`. So later you can check if the variable is a number or no.


Content Type	Original Author	Original Content on Stackoverflow
Question	Yariv	View Question on Stackoverflow
Solution 1 - Python	Pierre GM	View Answer on Stackoverflow
Solution 2 - Python	Julian	View Answer on Stackoverflow

Numpy integer nan

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

What is the purpose of passing arguments to anonymous functions in this manner?

How to check if a directory containing a file exist?

Attributions