In itom, the class dataObject is the main array object. Arrays in itom can have the following properties:
unlimited number of dimensions
each dimension can have an arbitrary size
"uint8" #unsigned integer, 8 bit [0,255]
"int8" #signed integer, 8 bit [-128,127]
"uint16" #unsigned integer, 16 bit [0,65536]
"int16" #signed integer, 16 bit [-32768,32767]
"uint32" #unsigned integer, 32 bit
"int32" #signed integer, 32 bit
"float32" #floating point, 32 bit single precision
"float64" #floating point, 64 bit double precision
"complex64" #complex number with two float32 components
"complex128" #complex number with two float64 components
Before giving a short tutorial about how to use the class dataObject, the base idea and concept of the array structure should be explained. If you already now the huge Python module Numpy with its base array class numpy.array, one will ask why another similar array class is provided by itom. The reasons for this are as follows:
In general, a dataObject is created like any other class instance in Python, hence the constructor of class dataObject is called. For a full reference of the constructor of class dataObject, type
help(dataObject)
In the following example, some dataObjects of different size and types are created. Using these constructors, the content of the created array is arbitrary at initialization:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | #1. empty dataObject, dimensions: 0, size: []
a = dataObject()
#2. one dimensional dataObject
# a one dimensional dataObject already is
# allocated as an array of size [1 x n]
b = dataObject([5], "float32") #size [1x5]
#3. 5 x 3 array, type: int8
c = dataObject([5,3], "int8")
#4. 2 x 5 x 10 array, type: complex128
# here two planes of size [5x10] are created and a vector with two items points to them
d = dataObject([2,5,10], "complex128")
#5. 2 x 5 x 10 array, type: complex128, continuous
# This matrix has the same size and type than matrix
# 'd' above. However, the continuous keyword indicates,
# that python should already allocate all planes in
# one block. Then the data object can be converted in
# a numpy.array without the need of copying the data block
# in memory. It is useful to use this keyword, if you
# often want to switch between dataObject and numpy.arrays.
# However consider that this is not recommended for huge
# matrices.
e = dataObject([2,5,10], "complex128", continuous = True)
|
You can also use the copy constructor of class dataObject in order to create a dataObject from another array-like object or a sequence of numbers (tuple, list...). In Python it is usual, that different objects share their memory (for arrays the memory is mainly the data block(s)) as long as possible, such that memory and execution time is saved. This is also the case when using the copy constructor. See the Numpy documentation for more information about this. The main thing you should know is, that if you change the value of any cell of an array, the corresponding value is also changed in all arrays, that share their memory with the dataObject.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | #1. create dataObject from any array-like object (e.g. Numpy array)
import numpy as np
a = np.ndarray([5,7])
b = dataObject(a) #b has the continuous flag set
#2. create dataObject from a tuple of values
# any object, that python can interpret as sequence can be used
# in order to initialize the data object. The dataObject can have
# an arbitrary size or number of dimensions, if the total number
# of elements fits to the length of the given input sequence.
# In this case, the sequence is totally copied into the data object.
# The values are filled row-by-row into the array, also called as
# c-continuous creation.
c = (2,7,4,3,8,9,6,2) #8 values
d = dataObject([2,4], data = c)
#3. create a dataObject as shallow copy of another dataObject
e = dataObject(d)
|
Some text about the basic idea of the dataObject and how it works. Some additional pictures.
For a detailed methods-summery of the dataObject see itom Script Reference.