cvrLattice1D.h

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2004
 * Lehrstuhl fuer Technische Informatik, RWTH-Aachen, Germany
 *
 * This file is part of the Computer Vision and Robotics Library (CVR-Lib)
 *
 * The CVR-Lib is free software; you can redistribute it and/or
 * modify it under the terms of the BSD License.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the authors nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * \file   cvrLattice1D.h
 *         Contains the template class cvr::lattice1D, which is the
 *         mathematical version of cvr::genericLattice1D.
 *         Some arithmetical operations have been added.
 * \author Pablo Alvarado
 * \date   17.01.2008
 *
 * $Id: cvrLattice1D.h,v 1.8 2007/04/06 01:18:41 alvarado Exp $
 */

#ifndef _CVR_LATTICE_1D_H_
#define _CVR_LATTICE_1D_H_

#define _CVR_GENERIC_LATTICE_1_D_DONT_INSTANTIATE_REQUEST
#include "cvrGenericLattice1D.h"
#undef _CVR_GENERIC_LATTICE_1_D_DONT_INSTANTIATE_REQUEST

namespace cvr {
  /**
   * Mathematical lattice1D container class.
   *
   * This container is inspired on mathematical integer lattices, at least with
   * respect to the indices, which are taken from \f$Z^n\f$ in the general
   * case with $n=1$ in this particular case.
   *
   * You can consider this a generalization of a cvr::vector, in which the
   * index of the first element is not necessarily zero, but a negative or
   * positive value.

   * The main goal of this class is to provide a \b fast implementation for
   * random access containers, addressable with negative indices, like filter
   * kernels, and since speed is the premise, it is achieved at some memory
   * costs.  This means this class has some storage overhead in order to
   * provide some information at zero time, like size, first and last indices
   * the begin and end iterators, etc., which is only possible by storing them
   * directly.
   *
   * Additionally to all functionality of the genericLattice1D, this class
   * provides additional arithmetical and mathematical operations.
   *
   * The following types are supported by cvr::lattice1D:
   * - ubyte
   * - byte
   * - char
   * - uint16
   * - int16
   * - int32
   * - uint32
   * - long
   * - float
   * - double
   * - rgbaPixel
   * - frgbPixel
   * - ipoint
   * - fpoint
   * - dpoint
   * - ipoint3D
   * - fpoint3D
   * - dpoint3D
   * - fcomplex
   * - dcomplex
   *
   * This restriction is done to avoid the typical template code explosion
   * due to frequently used types in the library.  If you need the lattice1D as
   * container of any other type, consider using cvr::genericLattice1D.
   *
   * The lattice1D class is a container class implemented as template, where
   * the template type T denotes the type of the elements.  It is by no means a
   * generic container, since the types it supports must fulfill many
   * requirements, specially support for all arithmetical operators, and the
   * types supported are explicitely instantiated in the library.
   *
   * @ingroup gAggregate
   * @ingroup gLinearAlgebra
   */
  template<typename T>
  class lattice1D : public genericLattice1D<T> {
  public:

    /**
     * \name Internal types and classes
     */
    //@{

    /**
     * Exception thrown when a constant reference is violated.
     */
    typedef cvr::constReferenceException constReferenceException;

    /**
     * Type of the genericLattice1D elements.
     */
    typedef typename genericLattice1D<T>::value_type value_type;

    /**
     * Return type of the size() member
     */
    typedef typename genericLattice1D<T>::size_type size_type;

    /**
     * Pointer to value_type
     */
    typedef typename genericLattice1D<T>::pointer pointer;

    /**
     * Const pointer to value_type
     */
    typedef typename genericLattice1D<T>::const_pointer const_pointer;
    
    /**
     * Reference to value_type
     */
    typedef typename genericLattice1D<T>::reference reference;

    /**
     * Const reference to value_type
     */
    typedef typename genericLattice1D<T>::const_reference const_reference;

    /**
     * \c iterator type (allows read and write operations).
     *
     * The use of the iterator classes is similar to the iterators of the STL
     * (Standard Template Library). See cvr::genericLattice1D::begin() and
     * cvr::genericLattice1D::inverseBegin() for examples.
     *
     * For the debugging version of the iterators, boundary check will be
     * done!  This explains the low speed of the iterators of the debug
     * version.  In the release version, no boundary check will be done,
     * and the iterators are sometimes a factor 10 faster than the
     * debug iterators.
     *
     * The use of the access operator at() is faster than the iterators in the
     * debug version only.  If you need to iterate on a genericLattice1D use
     * iterators instead (in the release version iterators are approximately a
     * factor 3 faster than at()).
     *
     * \warning Try to use the prefix incremental operator (i.e. ++it) instead
     * of the postfix operator (i.e. it++) to allow efficient code also in
     * debug-modus!
     *
     * @see genericLattice1D<T>::const_iterator
     */
    typedef typename genericLattice1D<T>::iterator iterator;

    /**
     * \c const_iterator type (allows read-only operations).
     *
     * The use of the iterator classes is similar to the iterators of the STL
     * (Standard Template Library). See cvr::genericLattice1D::begin() for an
     * example.
     *
     * For the debugging version of the iterators, boundary check will be
     * done!  This explains the low speed of the iterators of the debug
     * version.  In the release version, no boundary check will be done, and
     * the iterators are sometimes a factor 10 faster than the debug
     * iterators.
     *
     * The use of the access operator at() is faster than the iterators in the
     * debug version only.  If you need to iterate on a genericLattice1D use
     * iterators instead (in the release version iterators are approximately a
     * factor 3 faster than at()).
     *
     * \warning Try to use the prefix incremental operator (i.e. ++it) instead
     * of the postfix operator (i.e. it++) to allow efficient code also in
     * debug-modus!
     *
     * @see genericLattice1D<T>::iterator
     */
    typedef typename genericLattice1D<T>::const_iterator const_iterator;
    //@}

    /**
     * Default constructor creates an empty lattice1D;
     */
    lattice1D();

    /**
     * Create a lattice1D indexed by the given interval but do \b not
     * initialize its elements.
     *
     * @param from initial index.
     * @param to   final index.
     * 
     * The size of the container will be to-from+1.  The \c to value must be
     * greater or equal than the \c from value, otherwise an empty lattice will
     * be created.
     */
    explicit lattice1D(const size_type from,const size_type to);

    /**
     * Create a lattice1D indexed by the given interval but do \b not
     * initialize its elements.
     *
     * @param indices interval of indices to be used.
     */
    explicit lattice1D(const iinterval& indices);

    /**
     * Create a lattice1D indexed by the given interval and initialize
     * it with the given value.
     *
     * @param from initial index value
     * @param to final index value
     * @param iniValue all elements will be initialized with this value.
     */
    explicit lattice1D(const size_type from,
                       const size_type to,
                       const_reference iniValue);

    /**
     * Create a lattice1D indexed by the given interval and initialize
     * it with the given value.
     *
     * @param indices index interval
     * @param iniValue all elements will be initialized with this value.
     */
    explicit lattice1D(const iinterval& indices,
                       const_reference iniValue);

    /**
     * Create a lattice1D indexed by the given interval and initialize
     * it with the given data. The \a data will be copied.
     *
     * If you need to just use the memory block without copying it, then you
     * can wether use a third parameter of eConstantReference type or later
     * call the useExternData() method.
     *
     * @see useExternData()
     *
     * @param from initial index value
     * @param to final index value
     * @param data a pointer to the data that will be copied.
     */
    lattice1D(const size_type from,
              const size_type to,
              const value_type data[]);

    /**
     * Create a lattice1D indexed by the given interval and initialize
     * it with the given data. The \a data will be copied.
     *
     * If you need to just use the memory block without copying it, then you
     * can wether use a third parameter of eConstantReference type or later
     * call the useExternData() method.
     *
     * @see useExternData()
     *
     * @param indices index interval
     * @param data a pointer to the data that will be copied.
     */
    lattice1D(const iinterval& indices,
              const value_type data[]);

    /**
     * Create a lattice1D indexed by the given interval and initialize
     * it with the given data, the same way "useExternData" does, i.e. the 
     * \a data will \b not be copied!.
     *
     * @see useExternData()
     *
     * @param from initial index
     * @param to final index
     * @param data a pointer to the data that will be used.
     * @param constRef if this parameter is \c ConstantReference it will not be
     *                 possible to change the pointer to the external memory
     *                 block nor to resize the lattice1D.  Despite this,
     *                 the value of each element can be changed by the access
     *                 operators.
     */
    lattice1D(const size_type from,
              const size_type to,
              value_type data[],
              const eConstantReference constRef);

    /**
     * Create a lattice1D indexed by the given interval and initialize
     * it with the given data, the same way "useExternData" does, i.e. the 
     * \a data will \b not be copied!.
     *
     * @see useExternData()
     *
     * @param indices interval used for the lattice indices
     * @param data a pointer to the data that will be used.
     * @param constRef if this parameter is \c ConstantReference it will not be
     *                 possible to change the pointer to the external memory
     *                 block nor to resize the lattice1D.  Despite this,
     *                 the value of each element can be changed by the access
     *                 operators.
     */
    lattice1D(const iinterval& indices,
              value_type data[],
              const eConstantReference constRef);

    /**
     * Create this lattice1D as a copy of another lattice1D
     * @param other the lattice1D to be copied.
     */
    lattice1D(const genericLattice1D<T>& other);

    /**
     * Create this lattice1D as a copy of the specified interval of
     * elements of another lattice1D.  The \c from and \c to values are
     * truncated to the interval used by the \c other lattice.
     *
     * @param other the lattice1D to be copied.
     * @param from starting index of \c other lattice.
     * @param to end index of the \c other lattice.
     */
    lattice1D(const genericLattice1D<T>& other,
              const size_type from,
              const size_type to=container::MaxIndex);

    /**
     * Create this lattice1D as a copy of the specified interval of
     * elements of another lattice1D.  The \c from and \c to values are
     * truncated to the interval used by the \c other lattice.
     *
     * @param other the lattice1D to be copied.
     * @param indices index interval of the elements of \c other to be copied.
     */
    lattice1D(const genericLattice1D<T>& other,
              const iinterval& indices);


    /**
     * Create this lattice1D as a copy of another std::vector<T>
     *
     * @param other the lattice1D to be copied.
     * @param firstIndex index used for the first element of the vector.
     */
    lattice1D(const std::vector<T>& other,const int firstIndex=0);

    /**
     * Create this lattice1D as a copy of another cvr::genericVector.
     *
     * @param other the lattice1D to be copied.
     * @param firstIndex optional argument indicating which index is
     *        going to be assigned to the first vector element.
     */
    lattice1D(const genericVector<T>& other,const int firstIndex=0);

    /**
     * Destructor
     */
    virtual ~lattice1D();

    /**
     * Returns the name of this class.
     */
    const std::string& name() const;

    /**
     * Create a clone of this lattice1D.
     *
     * @return a pointer to a copy of this lattice1D
     */
    virtual lattice1D<T>* clone() const;

    /**
     * Create a new lattice1D instance.
     *
     * @return a pointer to a new instance of lattice1D
     */
    virtual lattice1D<T>* newInstance() const;

    /**
     * Compare this lattice1D with \c other, and use the given tolerance to
     * determine if the value of each element of the other lattice1D
     * approximately equals the values of the actual lattice1D elements.
     *
     * An element \a x is approximately equal to another element \a y
     * with a tolerance \a t, if following equation holds:
     * \a x-t < \a y < \a x+t.
     *
     * Both lattices must have exactly the same definition interval.  Otherwise
     * \c false is returned.
     *
     * @param other the other lattice1D to be compared with
     * @param tolerance the tolerance to be used
     *
     * @return true if both lattice1Ds are approximatly equal
     */
    bool prettyCloseTo(const genericLattice1D<T>& other,
                       const T& tolerance) const;

    /**
     * @name Arithmetical Operations
     */
    //@{
    /**
     * Dot product with another lattice1D of the \e same type.
     *
     * The dot product of lattices is here defined as the sum of the products
     * of elements sharing the same indices.  If the lattices have different
     * definition intervals, then only the common interval will be considered
     * (as it will be assumed that the other lattice has a zero in all other
     * undefined elements.
     * 
     * @param other the other lattice1D to be multiplied with
     * @return a scalar value with the type of the lattice1D elements
     */
    T dot(const genericLattice1D<T>& other) const;

    /**
     * Elementwise multiplication.
     *
     * Each element of this lattice1D will be multiplied with the corresponding
     * elements of the other lattice1D and the result will be left in this
     * %object! 
     *
     * If both lattice1Ds have different definition intervals, an assertion
     * will be thrown.
     *
     * @param other the other lattice1D to be multiplied with
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& emultiply(const genericLattice1D<T>& other);

    /**
     * Elementwise multiplication.
     *
     * This lattice1D will contain the elementwise multiplication of the
     * elements in \a first and \a second.
     *
     * If both lattice1Ds have different definition intervals, an assertion
     * will be thrown.
     *
     * @param first the first lattice1D
     * @param second the second lattice1D will be multiplied with the
     *               first lattice1D
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& emultiply(const genericLattice1D<T>& first,
                            const genericLattice1D<T>& second);

    /**
     * Elementwise division.
     *
     * Each element of this lattice1D will be divided by the elements
     * of the other lattice1D and the result will be left in this %object!
     * The returned lattice1D is this %object!
     *
     * If both lattice1Ds have different definition intervals, an assertion
     * will be thrown.
     *
     * @param other the other lattice1D to be divided by
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& edivide(const genericLattice1D<T>& other);

    /**
     * Elementwise division.
     *
     * This lattice1D will contain the elementwise division of the
     * elements in \a first by \a second.
     *
     * If both lattice1Ds have different definition intervals, an assertion
     * will be thrown
     *
     * @param first the first lattice1D
     * @param second the second lattice1D, is the divisor
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& edivide(const genericLattice1D<T>& first,
                          const genericLattice1D<T>& second);

    /**
     * Divide this lattice1D with a constant.  This lattice1D will be changed!
     * Returns this lattice1D.
     * synonym for divide(const T cst).
     * @param cst the elements of the lattice1D will be divided with this
     * constant
     * @return a reference to the actual lattice1D
     */
    inline lattice1D<T>& edivide(const T cst);

    /**
     * Divide the other lattice1D with a constant and leave the result here.
     * Returns a reference to this lattice1D. <p>
     * synonym for divide(const lattice1D<T>& other,const T cst).
     * @param other the lattice1D to be divide by the constant value
     * @param cst the elements of the lattice1D will be divided with this
     *            constant
     * @return a reference to the actual lattice1D
     */
    inline lattice1D<T>& edivide(const genericLattice1D<T>& other,const T cst);

    /**
     * Add another lattice1D of the same type and same dimension and
     * leave the result in this %object.
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param other the other lattice1D to be added with
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& add(const genericLattice1D<T>& other);

    /**
     * Add two lattice1D and leave the result in this %object.
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param first the first lattice1D
     * @param second the second lattice1D will be added with the first
     *               lattice1D
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& add(const genericLattice1D<T>& first,
                   const genericLattice1D<T>& second);

    /**
     * Add constant to this lattice1D.  This lattice1D is changed.
     * Returns this lattice1D.
     * @param cst constant scalar to be added with each element
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& add(const T cst);

    /**
     * Add constant to the other lattice1D and leave the result here.
     * Returns a reference to this lattice1D.
     * @param other the other lattice1D
     * @param cst constant scalar to be added with each element of the other
     *            lattice1D
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& add(const genericLattice1D<T>& other,const T cst);

    /**
     * Alias for add(const T cst)
     */
    inline lattice1D<T>& operator+=(const T cst);

    /**
     *  Alias for add(const lattice1D<T>& other)
     */
    inline lattice1D<T>& operator+=(const genericLattice1D<T>& other);

    /**
     * Add another lattice1D scaled by \e b to this lattice1D. The lattice1Ds
     * must be of the same types and dimensions. Let \e A be this lattice1D
     * and \e B the other lattice1D, then this method performs:<p>
     * \f$A=A+b\cdot B\f$
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param b scaling factor for \a other
     * @param other the lattice1D to be added after scaling
     * @return a reference to this lattice1D
     */
    lattice1D<T>& addScaled(const T b, const genericLattice1D<T>& other);

    /**
     * Leave the scaled %sum of two lattice1Ds in this lattice1D. The lattice1Ds
     * must be of the same types and dimensions. Let \e A be the
     * first lattice1D and \e B the second lattice1D with corresponding
     * scaling factors \e a and \e b, further \e C this
     * lattice1D, then this method performs:<p>
     * \f$C=a\cdot A+b\cdot B\f$
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param a scaling factor for \a first
     * @param first the first lattice1D to be added after scaling
     * @param b scaling factor for \a second
     * @param second the second lattice1D to be added after scaling
     * @return a reference to this lattice1D
     */
    lattice1D<T>& addScaled(const T a, const genericLattice1D<T>& first,
                         const T b, const genericLattice1D<T>& second);


    /**
     * Leave the addition of the first lattice1D and the second lattice1D
     * scaled with the given factor in this lattice1D. The lattice1Ds must
     * be of the same types and dimensions. Let \e A be the first
     * lattice1D and \e B the second lattice1D with corresponding scaling
     * factor \e b, further \e C this lattice1D, then this method
     * performs:<p> \f$C=A+b\cdot B\f$
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param first the first lattice1D to be added after scaling
     * @param b scaling factor for \a second
     * @param second the second lattice1D to be added after scaling
     * @return a reference to this lattice1D
     */
    lattice1D<T>& addScaled(const genericLattice1D<T>& first,
                         const T b,
                         const genericLattice1D<T>& second);

    /**
     * Subtract constant from this lattice1D.  This lattice1D is changed.
     * Returns this lattice1D.
     * @param cst constant scalar to be subtracted from each element
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& subtract(const T cst);

    /**
     * Subtract constant from the other lattice1D and leave the result here.
     * Returns a reference to this lattice1D.
     * @param other the other lattice1D
     * @param cst constant scalar to be subtracted from each element of the
     *            other lattice1D
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& subtract(const genericLattice1D<T>& other, const T cst);

    /**
     * Subtracts another lattice1D of the same type and same dimension
     * and leaves the result in this %object
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param other will be substracted from this lattice1D
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& subtract(const genericLattice1D<T>& other);

    /**
     * Subtracts two lattice1Ds and leaves the result in this %object.
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param first the first lattice1D
     * @param second the second lattice1D will be substracted from the
     *               first lattice1D
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& subtract(const genericLattice1D<T>& first,
                        const genericLattice1D<T>& second);

    /**
     * Alias for substract(const lattice1D<T>& other)
     * If both lattice1Ds have different size, an assertion will be thrown
     */
    inline lattice1D<T>& operator-=(const genericLattice1D<T>& other);

    /**
     * Alias for subtract(const T& cst)
     */
    lattice1D<T>& operator-=(const T cst);

    /**
     * Multiply this lattice1D with a constant.  This lattice1D will changed!
     * Returns this lattice1D.
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param cst constant scalar to be multiplied with
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& multiply(const T cst);

    /**
     * Multiply the other %lattice1D with a constant and leave the result here.
     * Returns a reference to this lattice1D.
     * If both lattice1Ds have different size, an assertion will be thrown
     * @param other the other lattice1D to be multiplied with the constant value
     * @param cst constant scalar to be multiplied with the other lattice1D.
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& multiply(const genericLattice1D<T>& other,const T cst);

    /**
     * Multiply with a constant.  This lattice1D is changed.
     * @param cst constant scalar to be multiplied with
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& operator*=(const T cst);

    /**
     * Divide this lattice1D by a constant.  This lattice1D will changed!
     * Returns this lattice1D.
     * @param cst the elements of the lattice1D will be divided with this
     * constant
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& divide(const T cst);

    /**
     * Divide the other lattice1D by a constant and leave the result here.
     * Returns a reference to this lattice1D.
     * @param other the lattice1D to be divide by the constant value
     * @param cst the elements of the lattice1D will be divided with this
     *            constant
     * @return a reference to the actual lattice1D
     */
    lattice1D<T>& divide(const genericLattice1D<T>& other,const T cst);

    /**
     * Alias for divide(const T& cst)
     */
    lattice1D<T>& operator/=(const T cst);

    /**
     * Calculate the sum of all elements of the lattice1D.
     * This member can be used with classes which define the operator '+='
     */
    T computeSumOfElements() const;

    /**
     * Calculate the product of all elements of the lattice1D.
     * This member can be used with classes which define the operator '*='
     */
    T computeProductOfElements() const;
    //@}


    /**
     * @name Find extreme values
     */
    //@{

    /**
     * Find the smallest element of the lattice1D
     */
    T findMinimum() const;

    /**
     * Find the index of the smallest element of the lattice1D
     */
    int findIndexOfMinimum() const;

    /**
     * Find the biggest element of the lattice1D
     */
    T findMaximum() const;

    /**
     * Find the index of the biggest element of the lattice1D
     */
    int findIndexOfMaximum() const;

    /**
     * Find the extremes of the lattice1D (smallest and biggest elements)
     */
    void findExtremes(T& theMinimum, T& theMaximum) const;

    /**
     * Find the indices of the extremes of the lattice1D
     * (smallest and biggest elements)
     */
    void findIndexOfExtremes(int& theIdxMinimum, int& theIdxMaximum) const;
    //@}
  };

} // namespace cvr

#include "cvrLattice1D_inline.h"

namespace cvr {
  /**
   *  Lattice1D of double
   */
  typedef lattice1D<double> dlattice1D;

  /**
   *  Lattice1D of float
   */
  typedef lattice1D<float>  flattice1D;

  /**
   *  Lattice1D of integer
   */
  typedef lattice1D<int32>  ilattice1D;

}

#endif