loading numpy arrays into fortran quickly

It depends on your data structures, but if it is just one or a few arrays you don't need any external libraries (I am not impressed with all the hassle of NetCDF).

import numpy as np
a = np.zeros([10, 10], order = "F")
a.tofile("a.bin")

and

  use iso_fortran_env
  real(real64)::a(10, 10)

  open(newunit = iu, file = "a.bin", access = "stream", status = "old", action = "read")
  read(iu) a
  close(iu)
  end

Suggestion : 2

np.array allows to specify whether the array is written in C-contiguous order (last index varies the fastest), or FORTRAN-contiguous order in memory (first index varies the fastest).,This function is obsolete and, because of changes due to relaxed stride checking, its return value for the same array may differ for versions of NumPy >= 1.10.0 and previous versions. If you only want to check if an array is Fortran contiguous use a.flags.f_contiguous instead.,Check if the array is Fortran contiguous but not C contiguous.,C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.

>>> a = np.array([
      [1, 2, 3],
      [4, 5, 6]
   ], order = 'C') >>>
   a
array([
      [1, 2, 3],
      [4, 5, 6]
   ]) >>>
   np.isfortran(a)
False

>>> b = np.array([
      [1, 2, 3],
      [4, 5, 6]
   ], order = 'F') >>>
   b
array([
      [1, 2, 3],
      [4, 5, 6]
   ]) >>>
   np.isfortran(b)
True

>>> a = np.array([
      [1, 2, 3],
      [4, 5, 6]
   ], order = 'C') >>>
   a
array([
      [1, 2, 3],
      [4, 5, 6]
   ]) >>>
   np.isfortran(a)
False
   >>>
   b = a.T >>>
   b
array([
      [1, 4],
      [2, 5],
      [3, 6]
   ]) >>>
   np.isfortran(b)
True

>>> np.isfortran(np.array([1, 2], order = 'F'))
False

Suggestion : 3

Last Updated : 29 Nov, 2018

Parameters :

array: [array_like] Input array

Return :

True,
if array is Fortran;
else False

Output :

Input array: [
   [1 2 3]
   [4 5 6]
]

isfortran: False

Suggestion : 4

In this chapter and throughout the book, I use the standard NumPy convention of always using import numpy as np. You are, of course, welcome to put from numpy import * in your code to avoid having to write np., but I would caution you against making a habit of this.,Fast vectorized array operations for data munging and cleaning, subsetting and filtering, transformation, and any other kinds of computations,See Table 4-1 for a short list of standard array creation functions. Since NumPy is focused on numerical computing, the data type, if not specified, will in many cases be float64 (floating point).,Standard mathematical functions for fast operations on entire arrays of data without having to write loops

In[13]: data1 = [6, 7.5, 8, 0, 1]

In[14]: arr1 = np.array(data1)

In[15]: arr1
Out[15]: array([6., 7.5, 8., 0., 1.])

In[27]: arr1 = np.array([1, 2, 3], dtype = np.float64)

In[28]: arr2 = np.array([1, 2, 3], dtype = np.int32)

In[29]: arr1.dtype In[30]: arr2.dtype
Out[29]: dtype('float64') Out[30]: dtype('int32')

In[45]: arr = np.array([
   [1., 2., 3.],
   [4., 5., 6.]
])

In[46]: arr
Out[46]:
   array([
      [1., 2., 3.],
      [4., 5., 6.]
   ])

In[47]: arr * arr In[48]: arr - arr
Out[47]: Out[48]:
   array([
      [1., 4., 9.], array([
         [0., 0., 0.],
         [16., 25., 36.]
      ])[0., 0., 0.]
   ])

In[51]: arr = np.arange(10)

In[52]: arr
Out[52]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In[53]: arr[5]
Out[53]: 5

In[54]: arr[5: 8]
Out[54]: array([5, 6, 7])

In[55]: arr[5: 8] = 12

In[56]: arr
Out[56]: array([0, 1, 2, 3, 4, 12, 12, 12, 8, 9])

In[75]: arr[1: 6]
Out[75]: array([1, 2, 3, 4, 64])

In[83]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])

In[84]: data = np.random.randn(7, 4)

In[85]: names
Out[85]:
   array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'],
      dtype = '|S4')

In[86]: data
Out[86]:
   array([
      [-0.048, 0.5433, -0.2349, 1.2792],
      [-0.268, 0.5465, 0.0939, -2.0445],
      [-0.047, -2.026, 0.7719, 0.3103],
      [2.1452, 0.8799, -0.0523, 0.0672],
      [-1.0023, -0.1698, 1.1503, 1.7289],
      [0.1913, 0.4544, 0.4519, 0.5535],
      [0.5994, 0.8174, -0.9297, -1.2564]
   ])

Suggestion : 5

Clearly, you can do math on arrays. Math in NumPy, is very fast because it is implemented in C or Fortran - just like most other high-level languages such as R, Matlab, etc do.,Many other libraries use NumPy arrays as the standard data structure: they take data in this format, and return it similarly. Thus, all the other packages you may want to use are compatible,By default, in NumPy all math is element-by-element. This is unlike Matlab, where most things are element-by-element, but * becomes array multiplication. NumPy values consistency and does not treat 2-dimensional arrays specially (numpy.add):,NumPy is the most used library for scientific computing. Even if you are not using it directly, chances are high that some library uses it in the background. NumPy provides the high-performance multidimensional array object and tools to use it.

a = list(range(10000))
b = [0] * 10000

% % timeit
for i in range(len(a)):
   b[i] = a[i] ** 2

import numpy as np
a = np.arange(10000)
b = np.zeros(10000)

% % timeit
b = a ** 2

a = np.array([1, 2, 3]) # 1 - dimensional array(rank 1)
b = np.array([
   [1, 2, 3],
   [4, 5, 6]
]) # 2 - dimensional array(rank 2)

b.shape # the shape(rows, columns)
b.size # number of elements

np.zeros((2, 3)) # 2 x3 array with all elements 0
np.ones((1, 2)) # 1 x2 array with all elements 1
np.full((2, 2), 7) # 2 x2 array with all elements 7
np.eye(2) # 2 x2 identity matrix

np.arange(10) # Evenly spaced values in an interval
np.linspace(0, 9, 10) # same as above, see exercise

c = np.ones((3, 3))
d = np.ones((3, 2), bool) # 3 x2 boolean array