Group Description

A N-dimensional grid class. It has the same interface and time complexity as vectors do. Having said that, construction can be slightly different and the time complexity for functions that are linear for the vector are actually O(N^dimensions) because each linear time function performs the same linear time function on each element, and so forth.

Example:

#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <codecogs\array\Grid.hpp>
#include <ctime>
using namespace std;
int main(int argc, char *argv[])
{
    std::vector<int> v;
    v.push_back(7); //first dimension
    v.push_back(6); //second dimension
    v.push_back(5); //third dimension
    //non-default ctor
    Grid<int, 3> g3d(v);
    Grid<int, 2> g2d(g3d.front());
    Grid<int, 1> g1d(g2d.back());
    Grid<int, 3> cube3d(3, g3d.front()); //3 in length
    //all 2d dimensions are the same as g3d.front()
    //dimension size checking
    cout << "First dimension: " << g1d.size() << endl;
    cout << "Second dimension: " << g2d.size() << endl;
    cout << "Third dimension: " << g3d.size() << endl;
    try //bounds checking
    {
        int x = g1d.at(9);
    }
    catch(const std::out_of_range& e)
    {
        cout << "Bounds checking test: " << e.what() << endl;
    }
    srand(time(NULL));
    for(int x = 0; x < 7; x++)
    {
        for(int y = 0; y < 6; y++)
        {
            for(int z = 0; z < 5; z++)
            {
                //operator[]
                //oppositly sorted
                g3d[z][y][x] = (100 - x) + (100 - y) + (100 - z);
            }
        }
    }
   cout << "Unsorted" << endl;
   //operators
   cout << (g3d[0] < g3d[1]) << endl;
   cout << (g3d[1] < g3d[0]) << endl;
   cout << (g3d[0] == g3d[0]) << endl;
   cout << (g3d[0] != g3d[0]) << endl;
   //begin/end/rbegin/rend
   sort(g3d.begin(), g3d.end());
   cout << "Sorted" << endl;
   cout << (g3d[0] < g3d[1]) << endl;
   cout << (g3d[1] < g3d[0]) << endl;
   cout << (g3d[0] == g3d[0]) << endl;
   cout << (g3d[0] != g3d[0]) << endl;
   return 0;
}

Output:

First dimension: 7
Second dimension: 6
Third dimension: 5
Bounds checking test: vector::_M_range_check
Unsorted
0
1
1
0
Sorted
1
0
1
0

Authors:

Sam Schetterer (June 2007)

Interface

#include <codecogs/array/grid.h>

		class Grid The N-dimensional grid class std::vector<...> elems The elements in the array typedefstd::vector<...> container The container used to hold elements typedefGrid<...> my_type The type of the Grid int N The size of the dimension typedefGrid<...> value_type The type held in the dimension typedef typename container::iterator iterator The type of iterator to be used to iterator over the values in the dimension typedef typename container::const_iterator const_iterator The type of const_iterator to be used to iterator over the values in the dimension typedefstd::reverse_iterator<iterator> reverse_iterator The reverse iterator typedefstd::reverse_iterator<...> const_reverse_iterator The reverse const_iterator typedef typename container::pointer pointer The pointer type to elements in the dimension typedef typename container::const_pointer const_pointer The const pointer type to elements in the dimension typedefvalue_type & reference The reference type to elements in the dimension typedefvalue_type & const_reference[const] The const reference type to elements in the dimension typedef alloc allocator_type The allocator type for elements in the dimension(will only be used for the 1-dimensional grid) typedef typename container::size_type size_type The size type used to reference elements in the dimension typedef typename container::difference_type difference_type The difference type between pointers [constructor] Grid () Constructs an empty grid [constructor] Grid (size_type length) Constructs a grid of length length [constructor] Grid (size_type length, const value_type& val) Constructs a grid of length with default value val [constructor] Grid (const my_type& a) Copy constructor template<...> explicit Grid (const Container& c) Constructs a grid using sizes for each dimension specified in c. The first object in c is the size of the first dimension, and so forth iterator begin () Returns the iterator at the begining of the dimension const_iterator begin () Returns the const iterator at the beginning of the dimension iterator end () Returns the iterator one element past the end of the dimension const_iterator end () Returns the const iterator one element past the end of the dimension reverse_iterator rbegin () Returns the reverse iterator at the beginning of the dimension const_reverse_iterator rbegin () Returns the const reverse iterator at the beginning of the dimension reverse_iterator rend () Returns the reverse iterator at the end of the dimension const_reverse_iterator rend () Returns the const reverse iterator at the end of the dimension reference* operator (size_type i) Returns a reference to the ith element in the dimension. Bounds are not checked const_reference* operator (size_type i) Return a const reference to the ith element in the dimension. Bounds are not checked reference front () Returns a reference first element in the dimension const_reference front () Returns a const reference to the first element in the dimension reference back () Returns a reference to the last element in the dimension const_reference back () Returns a const reference to the last element in the dimension reference at (size_type loc) Returns a reference to the loc-the element in the dimension. Bounds are checked, and an out_of_range exception is thrown when loc is out of bounds const_reference at (size_type loc) Returns a const reference to the loc-the element in the dimension. Bounds are checked, and an out_of_range exception is thrown when loc is out of bounds size_type size () Returns the size of the dimension bool empty () Returns whether the dimension is empty or not. A dimension can be empty but have non-zero capacity size_type max_size () Returns the maximum amount of elements in the dimension void swap (my_type& a) Swaps the dimension with another dimension my_type & operator= (const my_type& a) Sets the dimension equal to another dimension template<...> void assign (Itit first, Itit last) void assign (size_type number, const value_type& val) void insert (iterator position, size_type number, const value_type& val) iterator insert (iterator position, const value_type& val) template<...> void insert (iterator position, Itit first, Itit last) iterator erase (iterator position) iterator erase (iterator first, iterator last) void clear () void resize (size_type length, value_type val = value_type()) void push_back (const value_type& val) void pop_back () size_type capacity () void reserve (size_type num)
	template<...> bool	operator== (const Grid<T, dimensions, alloc>& a, const Grid<T, dimensions, alloc>& b)[inline] Element-by-element comparison functions
	template<...> bool	operator!= (const Grid<T, dimensions, alloc>& a, const Grid<T, dimensions, alloc>& b)[inline]
	template<...> bool	operator< (const Grid<T, dimensions, alloc>& a, const Grid<T, dimensions, alloc>& b)[inline]
	template<...> bool	operator> (const Grid<T, dimensions, alloc>& a, const Grid<T, dimensions, alloc>& b)[inline]
	template<...> bool	operator>= (const Grid<T, dimensions, alloc>& a, const Grid<T, dimensions, alloc>& b)[inline]
	template<...> bool	operator<= (const Grid<T, dimensions, alloc>& a, const Grid<T, dimensions, alloc>& b)[inline]
		class Grid<T, 1, alloc> The specialization for the Grid of the first dimension

---

Class Documentation

A N-dimensional grid class.

Source Code:

- To get code register with CodeCogs. Already a Member, then Login.