Returns a grid filled with the distances to the nearest atom. It will have the same bounds and points as other.

structure = Structure.read "path/to/file"
info = Grid::Info.new Parallelepiped[1.5, 2.135, 6.12], {10, 10, 10}
grid = Grid.atom_distance structure, info.dim, info.bounds
Grid.atom_distance_like(info, structure) == grid # => true

Creates a new Grid with info and yields a buffer to be filled.

This method is unsafe, but it is usually used to initialize the buffer in a linear fashion, e.g., reading values from a file.

Grid.build(Grid.info("/path/to/file")) do |buffer, size|
  size.times do |i|
    buffer[i] = read_value
  end
end

Returns a zero-filled grid with the same bounds and points as other.

grid = Grid.from_dx "/path/to/grid"
other = Grid.empty_like grid
other.bounds == grid.bounds # => true
other.dim == grid.dim       # => true
other.to_a.minmax           # => {0.0, 0.0}

Returns a grid with the same bounds and points as other filled with value.

grid = Grid.from_dx "/path/to/grid"
other = Grid.fill_like grid, 2345.123
other.bounds == grid.bounds # => true
other.dim == grid.dim       # => true
other.to_a.minmax           # => {2345.123, 2345.123}

Reads a grid from io in the given format. See also: IO#read_bytes. Raises IO::EOFError if there is missing data.

FIXME Make it compile time error. Should raise if format is not registered or format is incompatible with open_type. Better create an override with the other formats, and leave this as a fallback.

TODO add more tests

FIXME check delta calculation (grid.resolution.min / 2 shouldn't be enough?)

Returns a grid mask with the points at the vdW spheres set to 1. It will have the same bounds and points as other.

structure = Structure.read "path/to/file"
info = Grid::Info.new Parallelepiped[5.213, 6.823, 10.352], {20, 25, 40}
grid = Grid.vdw_mask structure, info.dim, info.bounds
Grid.vdw_mask_like(info, structure) == grid # => true

Returns true if this reference is the same as other. Invokes same?.

TODO add interpolation (check ARBInterp)

Returns a shallow copy of this object.

This allocates a new object and copies the contents of self into it.

Iterates over slices along axis. Axis is specified as an integer: 0-2 refer to the direction of the first, second or third basis vector, respectively.

grid = Grid.new({2, 3, 2}, Parallelepiped[1, 1, 1]) { |i, j, k| i * 6 + j * 2 + k }
grid.to_a # => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
slices = [] of Array(Float64)
grid.each_axial_slice(axis: 1) { |slice| slices << slice }
slices # => [[0, 1, 6, 7], [2, 3, 8, 9], [4, 5, 10, 11]]

When using read-only slices, one can specify the reuse option to prevent many memory allocations:

• If reuse is an Array, this array will be reused.
• If reuse is true, the method will create a new array and reuse it.
• If reuse is false (default), a new array is created and yielded on each iteration.

Returns an Array with the results of running the block against each element of the collection.

[1, 2, 3].map { |i| i * 10 } # => [10, 20, 30]

Like #map, but the block gets passed both the element and its index.

["Alice", "Bob"].map_with_index { |name, i| "User ##{i}: #{name}" }
# => ["User #0: Alice", "User #1: Bob"]

Accepts an optional offset parameter, which tells it to start counting from there.

Returns a grid mask. Elements for which the passed block returns true are set to 1, otherwise 0.

Grid masks are very useful to deal with multiple grids, and when points are to be selected based on one grid only.

grid = Grid.new({2, 2, 2}, Parallelepiped[10, 10, 10]) { |i, j, k| i + j + k }
grid.to_a              # => [0, 1, 1, 2, 1, 2, 2, 3]
grid.mask(&.>(1)).to_a # => [0, 0, 0, 1, 0, 1, 1, 1]
grid.to_a              # => [0, 1, 1, 2, 1, 2, 2, 3]

Returns a grid mask. Elements for which (value - ele).abs <= delta returns true are set to 1, otherwise 0.

Grid masks are very useful to deal with multiple grids, and when points are to be selected based on one grid only.

grid = Grid.new({2, 2, 3}, Parallelepiped[1, 1, 1]) { |i, j, k| (i + 1) * (j + 1) * (k + 1) / 5 }
grid.to_a              # => [0.2, 0.4, 0.6, 0.4, 0.8, 1.2, 0.4, 0.8, 1.2, 0.8, 1.6, 2.4]
grid.mask(1, 0.5).to_a # => [0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0]
grid.to_a              # => [0.2, 0.4, 0.6, 0.4, 0.8, 1.2, 0.4, 0.8, 1.2, 0.8, 1.6, 2.4]

Returns a grid mask. Elements for which pattern === element returns true are set to 1, otherwise 0.

Grid masks are very useful to deal with multiple grids, and when points are to be selected based on one grid only.

grid = Grid.new({2, 2, 3}, Parallelepiped[1, 1, 1]) { |i, j, k| (i + 1) * (j + 1) * (k + 1) }
grid.to_a              # => [1, 2, 3, 2, 4, 6, 2, 4, 6, 4, 8, 12]
grid.mask(2..4.5).to_a # => [0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0]
grid.to_a              # => [1, 2, 3, 2, 4, 6, 2, 4, 6, 4, 8, 12]

Masks a grid by the passed block. Elements for which the passed block returns false are set to 0.

Optimized version of creating a mask and applying it to the same grid, but avoids creating intermediate grids. This is equivalent to grid = grid * grid.mask { ... }.

grid = Grid.new({2, 2, 2}, Parallelepiped[10, 10, 10]) { |i, j, k| i + j + k }
grid.to_a # => [0, 1, 1, 2, 1, 2, 2, 3]
grid.mask! &.>(1)
grid.to_a # => [0, 0, 0, 2, 0, 2, 2, 3]

Masks a grid by value+/-delta. Elements for which (value - ele).abs > delta returns true are set to 0.

Optimized version of creating a mask and applying it to the same grid, but avoids creating intermediate grids. This is equivalent to grid = grid * grid.mask(value, delta)

grid = Grid.new({2, 2, 3}, Parallelepiped[1, 1, 1]) { |i, j, k| (i + j + k) / 5 }
grid.to_a # => [0.0, 0.2, 0.4, 0.2, 0.4, 0.6, 0.2, 0.4, 0.6, 0.4, 0.6, 0.8]
grid.mask! 0.5, 0.1
grid.to_a # => [0.0, 0.0, 0.4, 0.0, 0.4, 0.6, 0.0, 0.4, 0.6, 0.4, 0.6, 0.0]

Masks a grid by pattern. Elements for which pattern === element returns false are set to 0.

Optimized version of creating a mask and applying it to the same grid, but avoids creating intermediate grids. This is equivalent to grid = grid * grid.mask(pattern)

grid = Grid.new({2, 2, 3}, Parallelepiped[1, 1, 1]) { |i, j, k| (i + 1) * (j + 1) * (k + 1) }
grid.to_a # => [1, 2, 3, 2, 4, 6, 2, 4, 6, 4, 8, 12]
grid.mask! 2..4.5
grid.to_a # => [0, 2, 3, 2, 4, 0, 2, 4, 0, 4, 0, 0]

Returns a grid mask. Indexes for which the passed block returns true are set to 1, otherwise 0.

Grid masks are very useful to deal with multiple grids, and when points are to be selected based on one grid only.

grid = Grid.new({2, 2, 2}, Parallelepiped[10, 10, 10]) { |i, j, k| i * 4 + j * 2 + k }
grid.to_a                       # => [0, 1, 2, 3, 4, 5, 6, 7]
grid.mask_by_index(&.>(4)).to_a # => [0, 0, 0, 0, 0, 1, 1, 1]
grid.to_a                       # => [0, 1, 2, 3, 4, 5, 6, 7]

Masks a grid by index. Indexes for which the passed block returns false are set to 0.

Optimized version of creating a mask and applying it to the same grid, but avoids creating intermediate grids. This is equivalent to grid = grid * grid.mask_by_index { ... }

grid = Grid.new({2, 2, 2}, Parallelepiped[1, 1, 1]) { |i, j, k| i * 4 + j * 2 + k }
grid.to_a # => [0, 1, 2, 3, 4, 5, 6, 7]
grid.mask_by_index! &.<(3)
grid.to_a # => [0, 1, 2, 0, 0, 0, 0, 0]

Returns a grid mask. Locations for which the passed block returns true are set to 1, otherwise 0.

Grid masks are very useful to deal with multiple grids, and when points are to be selected based on one grid only.

grid = Grid.new({2, 2, 2}, Parallelepiped[10, 10, 10]) { |i, j, k| i * 4 + j * 2 + k }
grid.to_a                                  # => [0, 1, 2, 3, 4, 5, 6, 7]
grid.mask_by_loc { |i, j, k| k == 1 }.to_a # => [0, 1, 0, 1, 0, 1, 0, 1]
grid.to_a                                  # => [0, 1, 2, 3, 4, 5, 6, 7]

Masks a grid by location. Locations for which the passed block returns false are set to 0.

Optimized version of creating a mask and applying it to the same grid, but avoids creating intermediate grids. This is equivalent to grid = grid * grid.mask_by_loc { ... }

grid = Grid.new({2, 2, 2}, Parallelepiped[1, 1, 1]) { |i, j, k| i * 4 + j * 2 + k }
grid.to_a # => [0, 1, 2, 3, 4, 5, 6, 7]
grid.mask_by_loc! { |(i, j, k)| i == 1 }
grid.to_a # => [0, 0, 0, 0, 4, 5, 6, 7]

Returns a grid mask. Coordinates for which the passed block returns true are set to 1, otherwise 0.

Grid masks are very useful to deal with multiple grids, and when points are to be selected based on one grid only.

grid = Grid.new({2, 2, 2}, Parallelepiped[10, 10, 10]) { |i, j, k| i * 4 + j * 2 + k }
grid.to_a                        # => [0, 1, 2, 3, 4, 5, 6, 7]
grid.mask_by_pos(&.x.==(0)).to_a # => [1, 1, 1, 1, 0, 0, 0, 0]
grid.to_a                        # => [0, 1, 2, 3, 4, 5, 6, 7]

Masks a grid by coordinates. Coordinates for which the passed block returns false are set to 0.

Optimized version of creating a mask and applying it to the same grid, but avoids creating intermediate grids. This is equivalent to grid = grid * grid.mask_by_pos { ... }

grid = Grid.new({2, 2, 2}, Parallelepiped[5, 5, 5]) { |i, j, k| i * 4 + j * 2 + k }
grid.to_a # => [0, 1, 2, 3, 4, 5, 6, 7]
grid.mask_by_pos! { |vec| vec.y == 5 }
grid.to_a # => [0, 0, 2, 3, 0, 0, 6, 7]

Returns the arithmetic mean along axis. Axis is specified as an integer: 0-2 refer to the direction of the first, second or third basis vector, respectively.

Raises IndexError is axis is out of bounds.

grid = Grid.new({2, 3, 4}, Parallelepiped[1, 1, 1]) { |i, j, k| i * 12 + j * 4 + k }
grid.mean(axis: 0) # => [5.5, 17.5]
grid.mean(axis: 1) # => [7.5, 11.5, 15.5]
grid.mean(axis: 2) # => [10, 11, 12, 13]
grid.mean(axis: 3) # raises IndexError

Returns the arithmetic mean of the grid elements.

grid = Grid.new({2, 3, 4}, Parallelepiped[1, 1, 1]) { |i, j, k| i * 12 + j * 4 + k }
grid.mean # => 11.5

Returns the arithmetic mean along axis with its coordinates. Axis is specified as an integer: 0-2 refer to the direction of the first, second or third basis vector, respectively.

Raises IndexError is axis is out of bounds.

grid = Grid.new({2, 3, 5}, Parallelepiped[1, 1, 1]) { |i, j, k| i * 12 + j * 4 + k }
grid.mean(axis: 1) # => [{9.5, 0.0}, {14.5, 0.5}, {19.5, 1.0}]

Returns the number of elements in this container.

Returns an Array with all the elements in the collection.

(1..5).to_a # => [1, 2, 3, 4, 5]

Writes the binary representation of the grid to io in the given format. See also IO#write_bytes. Raises ArgumentError is the encoding is not UTF-8.

Returns the element at the given index, without doing any bounds check.

Indexable makes sure to invoke this method with index in 0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they access elements with #[](index) and #[]?(index).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

FIXME Make it compile time error. Should raise if format is not registered or format is incompatible with open_type. Better create an override with the other formats, and leave this as a fallback.