The astype method works well:

>>> numpy.float64('6374.345407799015').astype(str)
'6374.345407799015'

Do you care about the actual precision of the result, or about getting the exact same digits back from your two calculations?

If you just want the same digits, you could use np.around() to round the results to some appropriate number of decimal places. However, by doing this you'll only reduce the precision of the result.

If you actually want to compute the result more precisely, you could try using the np.longdouble type for your input array, which, depending on your architecture and compiler, might give you an 80- or 128-bit floating point representation, rather than the standard 64-bit np.double*.

You can compare the approximate number of decimal places of precision using np.finfo:

print np.finfo(np.double).precision
# 15

print np.finfo(np.longdouble).precision
# 18

Note that not all numpy functions will support long double - some will down-cast it to double.

*However, some compilers (such as Microsoft Visual C++) will always treat long double as synonymous with double, in which case there would be no difference in precision between np.longdouble and np.double.

You can just use standard string formatting:

>>> x = 1.2345678
>>> '%.2f' % x
'1.23'

IPython has formatters (core/formatters.py) which contain a dict that maps a type to a format method. There seems to be some knowledge of NumPy in the formatters but not for the np.float64 type.

There are a bunch of formatters, for HTML, LaTeX etc. but text/plain is the one for consoles.

We first get the IPython formatter for console text output

plain = get_ipython().display_formatter.formatters['text/plain']

and then set a formatter for the float64 type, we use the same formatter as already exists for float since it already knows about %precision

plain.for_type(np.float64, plain.lookup_by_type(float))

Now

In [26]: a = float(1.23456789)

In [28]: b = np.float64(1.23456789)

In [29]: %precision 3
Out[29]: '%.3f'

In [30]: a
Out[30]: 1.235

In [31]: b
Out[31]: 1.235

In the implementation I also found that %precision calls np.set_printoptions() with a suitable format string. I didn't know it did this, and potentially problematic if the user has already set this. Following the example above

In [32]: c = np.r_[a, a, a]

In [33]: c
Out[33]: array([1.235, 1.235, 1.235])

we see it is doing the right thing for array elements.

I can do this formatter initialisation explicitly in my own code, but a better fix might to modify IPython code/formatters.py line 677

    @default('type_printers')
    def _type_printers_default(self):
        d = pretty._type_pprinters.copy()
        d[float] = lambda obj,p,cycle: p.text(self.float_format%obj)
        # suggested "fix"
        if 'numpy' in sys.modules:
            d[numpy.float64] = lambda obj,p,cycle: p.text(self.float_format%obj)
        # end suggested fix
        return d

to also handle np.float64 here if NumPy is included. Happy for feedback on this, if I feel brave I might submit a PR.

As mentioned by @hpaulj in comments, it is not calculation precision. It is printing. Add this line to your code to see the precision you would like while printing in numpy:

np.set_printoptions(precision=16)

output of your code after above line:

dist1: [0.6858955910000049]
dist [0.6858955910000049]

From the numpy basics:

When operating with arrays of different types, the type of the resulting array corresponds to the more general or precise one (a behavior known as upcasting).

You can define the data type on the array creation. Applying a sum, multiplication or substraction, result will upcast to the "larger" type, it will also keep the dtype if you perform operations on the array, e.g.:

x = np.ones(10, dtype=np.float16)
y = np.ones(10, dtype=np.float32)
print((x + y).dtype, (x - y).dtype, (x * y).dtype)
print(np.sin(x).dtype, np.sin(y).dtype)
>> float32 float32 float32
   float16 float32

An exception is when passing an integer, in which case, by default, numpy upcasts to float64

print(np.sin(np.ones(10, dtype=int)).dtype)
>> float64