///////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2010, Industrial Light & Magic, a division of Lucas

// Digital Ltd. LLC

// 

// All rights reserved.

// 

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// *       Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// *       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.

// *       Neither the name of Industrial Light & Magic 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.

//

///////////////////////////////////////////////////////////////////////////

#include <testBoxAlgo.h>

#include "ImathBoxAlgo.h"

#include "ImathRandom.h"

#include <iostream>

#include <algorithm>

#include <assert.h>

#include <typeinfo>

#include <vector>

using namespace std;

using namespace IMATH_INTERNAL_NAMESPACE;

namespace {

//

// Test case generation utility - create a vector of IMATH_INTERNAL_NAMESPACE::Vec{2,3,4}

// with all permutations of integers 1..T::dimensions().

//

// Algorithm from www.bearcave.com/random_hacks/permute.html

//

template <class T>

static void

addItem(const std::vector<int> &value, std::vector<T> &perms)

{

    T p;

    for (unsigned int i = 0; i < value.size(); i++)

    {

        p[i] = value[i];

    }

    perms.push_back(p);

}

template <class T>

static void

visit(int &level, int n, int k, std::vector<int> &value, std::vector<T> &perms)

{

    level = level + 1;

    value[k] = level;

    if (level == n)

        addItem(value, perms);

    else

        for (int i = 0; i < n; i++)

            if (value[i] == 0)

                visit(level, n, i, value, perms);

    level = level - 1;

    value[k] = 0;

}

template <class T>

static void

permutations(std::vector<T> &perms)

{

    std::vector<int> value(T::dimensions());

    int level = -1;

    int n     = T::dimensions();

    visit(level, n, 0, value, perms);

}

template <class T>

static void

testConstructors(const char *type)

{

    cout << "    constructors for type " << type << endl;

    //

    // Empty

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        assert(b.min == T(T::baseTypeMax()) &&

               b.max == T(T::baseTypeMin()));

    }

    //

    // Single point

    //

    {

        T p;

        for (unsigned int i = 0; i < T::dimensions(); i++)

            p[i] = i;

        IMATH_INTERNAL_NAMESPACE::Box<T> b(p);

        assert(b.min == p && b.max == p);

    }

    //

    // Min and max

    //

    {

        T p0;

        T p1;

        for (unsigned int i = 0; i < T::dimensions(); i++)

        {

            p0[i] = i;

            p1[i] = 10 * T::dimensions() - i - 1;

        }

        IMATH_INTERNAL_NAMESPACE::Box<T> b(p0, p1);

        assert(b.min == p0 && b.max == p1);

    }

}

template <class T>

void

testMakeEmpty(const char *type)

{

    cout << "    makeEmpty() for type " << type << endl;

    //

    // Empty box

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        b.makeEmpty();

        assert(b.min == T(T::baseTypeMax()) &&

               b.max == T(T::baseTypeMin()));

    }

    //

    // Non-empty, has volume

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b(T(-1), T(1));

        b.makeEmpty();

        assert(b.min == T(T::baseTypeMax()) &&

               b.max == T(T::baseTypeMin()));

    }

    //

    // Non-empty, no volume

    // Boxes are:

    //    2D: [(0, 0),       (0, 1)      ]

    //    3D: [(0, 0, 0),    (0, 0, 1)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 1)]

    //

    {

        T min(0);

        T max(0);

        max[T::dimensions() - 1] = 1;

        IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);

        b.makeEmpty();

        assert(b.min == T(T::baseTypeMax()) &&

               b.max == T(T::baseTypeMin()));

    }

}

template <class T>

void

testMakeInfinite(const char *type)

{

    cout << "    makeInfinite() for type " << type << endl;

    //

    // Infinite box

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        b.makeInfinite();

        assert(b.min == T(T::baseTypeMin()) &&

               b.max == T(T::baseTypeMax()));

    }

    //

    // Non-empty, has volume

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b(T(-1), T(1));

        b.makeInfinite();

        assert(b.min == T(T::baseTypeMin()) &&

               b.max == T(T::baseTypeMax()));

    }

    //

    // Non-empty, no volume

    // Boxes are:

    //    2D: [(0, 0),       (0, 1)      ]

    //    3D: [(0, 0, 0),    (0, 0, 1)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 1)]

    //

    {

        T min(0);

        T max(0);

        max[T::dimensions() - 1] = 1;

        IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);

        b.makeInfinite();

        assert(b.min == T(T::baseTypeMin()) &&

               b.max == T(T::baseTypeMax()));

    }

}

template <class T>

void

testExtendByPoint(const char *type)

{

    cout << "    extendBy() point for type " << type << endl;

    IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);

    const unsigned int iters = 10;

    //

    // Extend empty box with a single point.

    //

    for (unsigned int i = 0; i < iters; i++)

    {

        T p;

        for (unsigned int j = 0; j < T::dimensions(); j++)

            p[j] = typename T::BaseType (rand.nextf(-12345, 12345));

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        b.extendBy(p);

        assert(b.min == p && b.max == p);

    }

    //

    // Extend empty box with a number of random points. Note that

    // this also covers extending a non-empty box.

    //

    for (unsigned int i = 0; i < iters; i++)

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        T min;

        T max;

        for (unsigned int j = 0; j < i; j++)

        {

            T p;

            for (unsigned int k = 0; k < T::dimensions(); k++)

                p[k] =  typename T::BaseType (rand.nextf(-12345, 12345));

            if (j == 0)

            {

                min = p;

                max = p;

            }

            for (unsigned int k = 0; k < T::dimensions(); k++)

            {

                min[k] = std::min(min[k], p[k]);

                max[k] = std::max(max[k], p[k]);

            }

            b.extendBy(p);

            assert(b.min == min && b.max == max);

        }

    }

}

template <class T>

void

testExtendByBox(const char *type)

{

    cout << "    extendBy() box for type " << type << endl;

    //

    // Extend empty box with an empty box;

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        b.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>());

        assert(b.min == T(T::baseTypeMax()) &&

               b.max == T(T::baseTypeMin()));

    }

    //

    // Extend empty box with a non-empty box and vice versa.

    //

    {

        std::vector<T> perms;

        permutations(perms);

        for (unsigned int i = 0; i < perms.size(); i++)

        {

            for (unsigned int j = 0; j < perms.size(); j++)

            {

                T p0 = -perms[i];

                T p1 =  perms[j];

                IMATH_INTERNAL_NAMESPACE::Box<T> b0;

                b0.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>(p0, p1));

                assert(b0.min == p0 && b0.max == p1);

                IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);

                b1.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>());

                assert(b1.min == p0 && b1.max == p1);

            }

        }

    }

    //

    // Extend non-empty box with non-empty box. Starts with empty, then builds.

    //

    IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);

    const unsigned int iters = 10;

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        T min, max;

        for (unsigned int i = 1; i < iters; i++)

        {

            T p0;

            T p1;

            for (unsigned int k = 0; k < T::dimensions(); k++)

            {

                p0[k] = typename T::BaseType (rand.nextf(   0,  999));

                p1[k] = typename T::BaseType (rand.nextf(1000, 1999));

            }

            min = b.min;

            max = b.max;

            for (unsigned int k = 0; k < T::dimensions(); k++)

            {

                min[k] = std::min(min[k], p0[k]);

                max[k] = std::max(max[k], p1[k]);

            }

            b.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>(p0, p1));

            assert(b.min == min && b.max == max);

        }

    }

}

template <class T>

void

testComparators(const char *type)

{

    cout << "    comparators for type " << type << endl;

    IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);

    //

    // Compare empty.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0;

        IMATH_INTERNAL_NAMESPACE::Box<T> b1;

        assert(b0 == b1);

        assert(!(b0 != b1));

    }

    //

    // Compare empty to non-empty.

    //

    {

        std::vector<T> perms;

        permutations(perms);

        for (unsigned int i = 0; i < perms.size(); i++)

        {

            for (unsigned int j = 0; j < perms.size(); j++)

            {

                T p0 = -perms[i];

                T p1 =  perms[j];

                IMATH_INTERNAL_NAMESPACE::Box<T> b0;

                IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);

                assert(!(b0 == b1));

                assert(b0 != b1);

            }

        }

    }

    //

    // Compare two non-empty

    //

    {

        std::vector<T> perms;

        permutations(perms);

        for (unsigned int i = 0; i < perms.size(); i++)

        {

            for (unsigned int j = 0; j < perms.size(); j++)

            {

                T p0 = -perms[i];

                T p1 =  perms[j];

                T p2 = -perms[j];

                T p3 =  perms[i];

                IMATH_INTERNAL_NAMESPACE::Box<T> b0(p0, p1);

                IMATH_INTERNAL_NAMESPACE::Box<T> b1(p2, p3);

                IMATH_INTERNAL_NAMESPACE::Box<T> b2(p0, p1);

                if (i == j)

                {

                    assert(b0 == b1);

                    assert(!(b0 != b1));

                }

                else

                {

                    assert(b0 != b1);

                    assert(!(b0 == b1));

                }

                assert(b0 == b2);

                assert(!(b0 != b2));

            }

        }

    }

}

template <class T>

void

testIntersects(const char *type)

{

    cout << "    intersects() for type " << type << endl;

    IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);

    //

    // Intersect point with empty box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        T             p(1);

        assert(!b.intersects(p));

    }

    //

    // Intersect point with non-empty, has-volume box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b(T(-1), T(1));

        T             p0(0);

        T             p1(5);

        T             p2(-5);

        assert(b.intersects(p0));

        assert(!b.intersects(p1));

        assert(!b.intersects(p2));

    }

    //

    // Intersect point with non-empty, no-volume box.

    // Boxes are:

    //    2D: [(0, 0),       (0, 1)      ]

    //    3D: [(0, 0, 0),    (0, 0, 1)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 1)]

    //

    {

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 1;

        T p0(0);

        T p1(5);

        IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);

        assert(b.intersects(p0));

        assert(!b.intersects(p1));

    }

    //

    // Intersect empty box with empty box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0;

        IMATH_INTERNAL_NAMESPACE::Box<T> b1;

        assert(!b0.intersects(b1));

        assert(!b1.intersects(b0));

    }

    //

    // Intersect empty box with non-empty has-volume boxes.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0;

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(T(-1), T(1));

        IMATH_INTERNAL_NAMESPACE::Box<T> b2(T( 1), T(2));

        assert(!b0.intersects(b1));

        assert(!b0.intersects(b2));

        assert(!b1.intersects(b0));

        assert(!b2.intersects(b0));

    }

    //

    // Intersect empty box with non-empty no-volume box.

    // Boxes are:

    //    2D: [(0, 0),       (0, 1)      ]

    //    3D: [(0, 0, 0),    (0, 0, 1)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 1)]

    //

    {

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 1;

        IMATH_INTERNAL_NAMESPACE::Box<T> b0;

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(min, max);

        assert(!b0.intersects(b1));

        assert(!b1.intersects(b0));

    }

    //

    // Intersect non-empty has-volume box with non-empty has-volume box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(T(-1), T(1));

        IMATH_INTERNAL_NAMESPACE::Box<T> b2(T(-1), T(1));

        IMATH_INTERNAL_NAMESPACE::Box<T> b3(T( 1), T(2));

        IMATH_INTERNAL_NAMESPACE::Box<T> b4(T( 2), T(3));

        assert(b1.intersects(b1));

        assert(b1.intersects(b3));

        assert(!b1.intersects(b4));

        assert(b3.intersects(b1));

        assert(!b4.intersects(b1));

    }

    //

    // Intersect non-empty has-volume box with non-empty no-volume box.

    //

    // Boxes are:

    //    2D: [(0, 0),       (0, 1)      ]

    //    3D: [(0, 0, 0),    (0, 0, 1)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 1)]

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 1;

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(min, max);

        IMATH_INTERNAL_NAMESPACE::Box<T> b2(min + T(2), max + T(2));

        assert(b0.intersects(b1));

        assert(b1.intersects(b0));

        assert(!b0.intersects(b2));

        assert(!b2.intersects(b1));

    }

    //

    // Intersect non-empty no-volume box with non-empty no-volume box.

    //

    // Boxes are:

    //    2D: [(0, 0),       (0, 1)      ]

    //    3D: [(0, 0, 0),    (0, 0, 1)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 1)]

    //

    {

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 1;

        IMATH_INTERNAL_NAMESPACE::Box<T> b0(min, max);

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(min,  max + T(2));

        IMATH_INTERNAL_NAMESPACE::Box<T> b2(min + T(2),  max + T(2));

        assert(b0.intersects(b1));

        assert(b1.intersects(b0));

        assert(!b0.intersects(b2));

        assert(!b2.intersects(b0));

    }

}

template <class T>

void

testSize(const char *type)

{

    cout << "    size() for type " << type << endl;

    //

    // Size of empty box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        assert(b.size() == T(0));

    }

    //

    // Size of non-empty, has-volume box.

    // Boxes are:

    //    2D: [(-1, -1),         (1, 1)       ]

    //    3D: [(-1, -1, -1),     (1, 1, 1)    ]

    //    4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ] 

    //

    // and

    //

    //    2D: [(-1, -2),         (1, 2)       ]

    //    3D: [(-1, -2, -3),     (1, 2, 3)    ]

    //    4D: [(-1, -2, -3, -4), (1, 2, 3, 4) ]

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));

        assert(b0.size() == T(2));

        T p;

        for (unsigned int i = 0; i < T::dimensions(); i++)

        {

            p[i] = i;

        }

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(-p, p);

        assert(b1.size() == p * T(2));

    }

    //

    // Size of non-empty, no-volume box.

    // Boxes are:

    //    2D: [(0, 0),       (0, 1)      ]

    //    3D: [(0, 0, 0),    (0, 0, 1)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 1)]

    //

    {

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 1;

        IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);

        assert(b.size() == max);

    }

}

template <class T>

void

testCenter(const char *type)

{

    cout << "    center() for type " << type << endl;

    //

    // Center of empty box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        assert(b.center() == T(0));

    }

    //

    // Center of non-empty, has-volume box.

    // Boxes are:

    //    2D: [(-1, -1),         (1, 1)       ]

    //    3D: [(-1, -1, -1),     (1, 1, 1)    ]

    //    4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ] 

    //

    // and

    //

    //    2D: [(-2, -4),         ( 8,  2)       ]

    //    3D: [(-2, -4, -6),     (12,  8, 2)    ]

    //    4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));

        assert(b0.center() == T(0));

        T p0;

        T p1;

        for (unsigned int i = 0; i < T::dimensions(); i++)

        {

            p0[i] = -typename T::BaseType(1 << (i + 1));

            p1[i] =  typename T::BaseType(1 << (T::dimensions() - i));

        }

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);

        assert(b1.center() == (p1 + p0) / 2);

    }

    //

    // Center of non-empty, no-volume box.

    // Boxes are:

    //    2D: [(0, 0),       (0, 2)      ]

    //    3D: [(0, 0, 0),    (0, 0, 2)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 2)]

    //

    {

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 2;

        IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);

        assert(b.center() == max /2);

    }

}

template <class T>

void

testIsEmpty(const char *type)

{

    cout << "    isEmpty() for type " << type << endl;

    //

    // Empty box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        assert(b.isEmpty());

    }

    //

    // Non-empty, has-volume box.

    //    2D: [(-2, -4),         ( 8,  2)       ]

    //    3D: [(-2, -4, -6),     (12,  8, 2)    ]

    //    4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));

        assert(!b0.isEmpty());

        T p0;

        T p1;

        for (unsigned int i = 0; i < T::dimensions(); i++)

        {

           p0[i] = -typename T::BaseType(1 << (i + 1));

           p1[i] =  typename T::BaseType(1 << (T::dimensions() - i));

        }

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);

        assert(!b1.isEmpty());

    }

    //

    // Non-empty, no-volume box.

    // Boxes are:

    //    2D: [(0, 0),       (0, 2)      ]

    //    3D: [(0, 0, 0),    (0, 0, 2)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 2)]

    //

    {

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 2;

        IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);

        assert(!b.isEmpty());

    }

}

template <class T>

void

testIsInfinite(const char *type)

{

    cout << "    isInfinite() for type " << type << endl;

    //

    // Infinite box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        b.makeInfinite();

        assert(b.isInfinite());

    }

    //

    // Non-empty, has-volume box.

    //    2D: [(-2, -4),         ( 8,  2)       ]

    //    3D: [(-2, -4, -6),     (12,  8, 2)    ]

    //    4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));

        assert(!b0.isInfinite());

        T p0;

        T p1;

        for (unsigned int i = 0; i < T::dimensions(); i++)

        {

            p0[i] = -typename T::BaseType(1 << (i + 1));

            p1[i] =  typename T::BaseType(1 << (T::dimensions() - i));

        }

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);

        assert(!b1.isInfinite());

    }

    //

    // Non-empty, no-volume box.

    // Boxes are:

    //    2D: [(0, 0),       (0, 2)      ]

    //    3D: [(0, 0, 0),    (0, 0, 2)   ]

    //    4D: [(0, 0, 0, 0), (0, 0, 0, 2)]

    //

    {

        T min(0);

        T max = min;

        max[T::dimensions() - 1] = 2;

        IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);

        assert(!b.isInfinite());

    }

}

template <class T>

void

testHasVolume(const char *type)

{

    cout << "    hasVolume() for type " << type << endl;

    //

    // Empty box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        assert(!b.hasVolume());

    }

    //

    // Infinite box.

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b;

        b.makeInfinite();

        assert(b.hasVolume());

    }

    //

    // Non-empty, has-volume box.

    //    2D: [(-2, -4),         ( 8,  2)       ]

    //    3D: [(-2, -4, -6),     (12,  8, 2)    ]

    //    4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]

    //

    {

        IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));

        assert(b0.hasVolume());

        T p0;

        T p1;

        for (unsigned int i = 0; i < T::dimensions(); i++)

        {

            p0[i] = -typename T::BaseType(1 << (i + 1));

            p1[i] =  typename T::BaseType(1 << (T::dimensions() - i));

        }

        IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);

        assert(b1.hasVolume());