OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	10/28/2024 06:50:42 AM	rwxr-xr-x
📄 Iex.h	2.34 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexBaseExc.h	9.06 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexErrnoExc.h	7.37 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexExport.h	2.08 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexForward.h	5.1 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexMacros.h	5.63 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexMathExc.h	2.41 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexMathFloatExc.h	4.58 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexMathFpu.h	3.3 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexMathIeeeExc.h	2.3 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexNamespace.h	4.3 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IexThrowErrnoExc.h	3.4 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 IlmBaseConfig.h	1.64 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 IlmThread.h	4.78 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 IlmThreadExport.h	2.15 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 IlmThreadForward.h	2.08 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 IlmThreadMutex.h	4.32 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 IlmThreadNamespace.h	4.54 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 IlmThreadPool.h	5.21 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 IlmThreadSemaphore.h	3.38 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathBox.h	16.62 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathBoxAlgo.h	22.35 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathColor.h	14.87 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathColorAlgo.h	7.08 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathEuler.h	22.88 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathExc.h	2.82 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathExport.h	2.13 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathForward.h	2.68 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathFrame.h	6.6 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathFrustum.h	22.26 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathFrustumTest.h	14.77 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathFun.h	5.99 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathGL.h	4.52 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathGLU.h	2.17 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathHalfLimits.h	2.47 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathInt64.h	2.4 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathInterval.h	5.34 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathLimits.h	7.76 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathLine.h	4.74 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathLineAlgo.h	7.68 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathMath.h	7.17 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathMatrix.h	82.42 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathMatrixAlgo.h	37.97 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathNamespace.h	4.38 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathPlane.h	6.75 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathPlatform.h	3.23 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathQuat.h	20.94 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathRandom.h	9.84 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathRoots.h	5.62 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathShear.h	13.85 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathSphere.h	4.68 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathVec.h	44.17 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImathVecAlgo.h	4.64 KB	04/16/2016 12:52:00 AM	rw-r--r--
📄 ImfAcesFile.h	10.27 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfArray.h	6.79 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfAttribute.h	10.36 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfB44Compressor.h	3.67 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfBoxAttribute.h	3.1 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfCRgbaFile.h	12.5 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfChannelList.h	11.2 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfChannelListAttribute.h	2.69 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfChromaticities.h	4.45 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfChromaticitiesAttribute.h	2.74 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfCompositeDeepScanLine.h	5.38 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfCompression.h	3.25 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfCompressionAttribute.h	2.71 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfConvert.h	3.39 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepCompositing.h	5.97 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepFrameBuffer.h	8.79 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepImageState.h	3.67 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepImageStateAttribute.h	2.64 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepScanLineInputFile.h	11.01 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepScanLineInputPart.h	6.9 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepScanLineOutputFile.h	9.37 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepScanLineOutputPart.h	6.41 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepTiledInputFile.h	16.08 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepTiledInputPart.h	13.27 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepTiledOutputFile.h	18.1 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDeepTiledOutputPart.h	14.83 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfDoubleAttribute.h	2.29 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfEnvmap.h	11.29 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfEnvmapAttribute.h	2.67 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfExport.h	2.11 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfFloatAttribute.h	2.26 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfForward.h	3.48 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfFrameBuffer.h	11.18 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfFramesPerSecond.h	3.79 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfGenericInputFile.h	2.26 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfGenericOutputFile.h	2.44 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfHeader.h	19.27 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfHuf.h	2.86 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfIO.h	7.45 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfInputFile.h	8.28 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfInputPart.h	3.52 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfInt64.h	2.24 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfIntAttribute.h	2.27 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfKeyCode.h	4.9 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfKeyCodeAttribute.h	2.65 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfLineOrder.h	2.42 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfLineOrderAttribute.h	2.67 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfLut.h	5.12 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfMatrixAttribute.h	3.65 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfMisc.h	16.33 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfMultiPartInputFile.h	3.94 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfMultiPartOutputFile.h	4.29 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfMultiView.h	6.29 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfName.h	3.52 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfNamespace.h	4.46 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfOpaqueAttribute.h	3.55 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfOutputFile.h	9.66 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfOutputPart.h	3.04 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfPartHelper.h	7.66 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfPartType.h	2.38 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfPixelType.h	2.34 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfPreviewImage.h	4.65 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfPreviewImageAttribute.h	2.68 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfRational.h	3.17 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfRationalAttribute.h	2.63 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfRgba.h	3.08 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfRgbaFile.h	13.09 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfRgbaYca.h	8.21 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfStandardAttributes.h	13.26 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfStringAttribute.h	2.58 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfStringVectorAttribute.h	2.7 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTestFile.h	3.55 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfThreading.h	4.24 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTileDescription.h	3.13 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTileDescriptionAttribute.h	2.7 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTiledInputFile.h	13.82 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTiledInputPart.h	4.55 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTiledOutputFile.h	17.83 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTiledOutputPart.h	4.75 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTiledRgbaFile.h	15.89 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTimeCode.h	7 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfTimeCodeAttribute.h	2.64 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfVecAttribute.h	4.45 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfVersion.h	4.64 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfWav.h	2.73 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 ImfXdr.h	18.74 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 OpenEXRConfig.h	1.8 KB	11/16/2021 03:51:38 PM	rw-r--r--
📄 half.h	17.22 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 halfExport.h	757 bytes	04/16/2016 12:51:59 AM	rw-r--r--
📄 halfFunction.h	4.83 KB	04/16/2016 12:51:59 AM	rw-r--r--
📄 halfLimits.h	3.73 KB	04/16/2016 12:51:59 AM	rw-r--r--

Editing: ImathShear.h

///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2004-2012, 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.
//
///////////////////////////////////////////////////////////////////////////

#ifndef INCLUDED_IMATHSHEAR_H
#define INCLUDED_IMATHSHEAR_H

//----------------------------------------------------
//
//	Shear6 class template.
//
//----------------------------------------------------

#include "ImathExc.h"
#include "ImathLimits.h"
#include "ImathMath.h"
#include "ImathVec.h"
#include "ImathNamespace.h"
#include <iostream>

IMATH_INTERNAL_NAMESPACE_HEADER_ENTER

template <class T> class Shear6
{
  public:

//-------------------
    // Access to elements
    //-------------------

T			xy, xz, yz, yx, zx, zy;

T &			operator [] (int i);
    const T &		operator [] (int i) const;

//-------------
    // Constructors
    //-------------

Shear6 ();			   // (0 0 0 0 0 0)
    Shear6 (T XY, T XZ, T YZ);	   // (XY XZ YZ 0 0 0)
    Shear6 (const Vec3<T> &v);     // (v.x v.y v.z 0 0 0)
    template <class S>             // (v.x v.y v.z 0 0 0)
	Shear6 (const Vec3<S> &v);
    Shear6 (T XY, T XZ, T YZ,      // (XY XZ YZ YX ZX ZY)
	    T YX, T ZX, T ZY);

//---------------------------------
    // Copy constructors and assignment
    //---------------------------------

Shear6 (const Shear6 &h);
    template <class S> Shear6 (const Shear6<S> &h);

const Shear6 &	operator = (const Shear6 &h);
    template <class S> 
	const Shear6 &	operator = (const Vec3<S> &v);

//----------------------
    // Compatibility with Sb
    //----------------------

template <class S>
    void		setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY);

template <class S>
    void		setValue (const Shear6<S> &h);

template <class S>
    void		getValue (S &XY, S &XZ, S &YZ, 
				  S &YX, S &ZX, S &ZY) const;

template <class S>
    void		getValue (Shear6<S> &h) const;

T *			getValue();
    const T *		getValue() const;

//---------
    // Equality
    //---------

template <class S>
    bool		operator == (const Shear6<S> &h) const;

template <class S>
    bool		operator != (const Shear6<S> &h) const;

//-----------------------------------------------------------------------
    // Compare two shears and test if they are "approximately equal":
    //
    // equalWithAbsError (h, e)
    //
    //	    Returns true if the coefficients of this and h are the same with
    //	    an absolute error of no more than e, i.e., for all i
    //
    //      abs (this[i] - h[i]) <= e
    //
    // equalWithRelError (h, e)
    //
    //	    Returns true if the coefficients of this and h are the same with
    //	    a relative error of no more than e, i.e., for all i
    //
    //      abs (this[i] - h[i]) <= e * abs (this[i])
    //-----------------------------------------------------------------------

bool		equalWithAbsError (const Shear6<T> &h, T e) const;
    bool		equalWithRelError (const Shear6<T> &h, T e) const;

//------------------------
    // Component-wise addition
    //------------------------

const Shear6 &	operator += (const Shear6 &h);
    Shear6		operator + (const Shear6 &h) const;

//---------------------------
    // Component-wise subtraction
    //---------------------------

const Shear6 &	operator -= (const Shear6 &h);
    Shear6		operator - (const Shear6 &h) const;

//------------------------------------
    // Component-wise multiplication by -1
    //------------------------------------

Shear6		operator - () const;
    const Shear6 &	negate ();

//------------------------------
    // Component-wise multiplication
    //------------------------------

const Shear6 &	operator *= (const Shear6 &h);
    const Shear6 &	operator *= (T a);
    Shear6		operator * (const Shear6 &h) const;
    Shear6		operator * (T a) const;

//------------------------
    // Component-wise division
    //------------------------

const Shear6 &	operator /= (const Shear6 &h);
    const Shear6 &	operator /= (T a);
    Shear6		operator / (const Shear6 &h) const;
    Shear6		operator / (T a) const;

//----------------------------------------------------------
    // Number of dimensions, i.e. number of elements in a Shear6
    //----------------------------------------------------------

static unsigned int	dimensions() {return 6;}

//-------------------------------------------------
    // Limitations of type T (see also class limits<T>)
    //-------------------------------------------------

static T		baseTypeMin()		{return limits<T>::min();}
    static T		baseTypeMax()		{return limits<T>::max();}
    static T		baseTypeSmallest()	{return limits<T>::smallest();}
    static T		baseTypeEpsilon()	{return limits<T>::epsilon();}

//--------------------------------------------------------------
    // Base type -- in templates, which accept a parameter, V, which
    // could be either a Vec2<T> or a Shear6<T>, you can refer to T as
    // V::BaseType
    //--------------------------------------------------------------

typedef T		BaseType;
};

//--------------
// Stream output
//--------------

template <class T>
std::ostream &	operator << (std::ostream &s, const Shear6<T> &h);

//----------------------------------------------------
// Reverse multiplication: scalar * Shear6<T>
//----------------------------------------------------

template <class S, class T> Shear6<T>	operator * (S a, const Shear6<T> &h);

//-------------------------
// Typedefs for convenience
//-------------------------

typedef Vec3   <float>  Shear3f;
typedef Vec3   <double> Shear3d;
typedef Shear6 <float>  Shear6f;
typedef Shear6 <double> Shear6d;

//-----------------------
// Implementation of Shear6
//-----------------------

template <class T>
inline T &
Shear6<T>::operator [] (int i)
{
    return (&xy)[i];
}

template <class T>
inline const T &
Shear6<T>::operator [] (int i) const
{
    return (&xy)[i];
}

template <class T>
inline
Shear6<T>::Shear6 ()
{
    xy = xz = yz = yx = zx = zy = 0;
}

template <class T>
inline
Shear6<T>::Shear6 (T XY, T XZ, T YZ)
{
    xy = XY;
    xz = XZ;
    yz = YZ;
    yx = 0;
    zx = 0;
    zy = 0;
}

template <class T>
inline
Shear6<T>::Shear6 (const Vec3<T> &v)
{
    xy = v.x;
    xz = v.y;
    yz = v.z;
    yx = 0;
    zx = 0;
    zy = 0;
}

template <class T>
template <class S>
inline
Shear6<T>::Shear6 (const Vec3<S> &v)
{
    xy = T (v.x);
    xz = T (v.y);
    yz = T (v.z);
    yx = 0;
    zx = 0;
    zy = 0;
}

template <class T>
inline
Shear6<T>::Shear6 (T XY, T XZ, T YZ, T YX, T ZX, T ZY)
{
    xy = XY;
    xz = XZ;
    yz = YZ;
    yx = YX;
    zx = ZX;
    zy = ZY;
}

template <class T>
inline
Shear6<T>::Shear6 (const Shear6 &h)
{
    xy = h.xy;
    xz = h.xz;
    yz = h.yz;
    yx = h.yx;
    zx = h.zx;
    zy = h.zy;
}

template <class T>
template <class S>
inline
Shear6<T>::Shear6 (const Shear6<S> &h)
{
    xy = T (h.xy);
    xz = T (h.xz);
    yz = T (h.yz);
    yx = T (h.yx);
    zx = T (h.zx);
    zy = T (h.zy);
}

template <class T>
inline const Shear6<T> &
Shear6<T>::operator = (const Shear6 &h)
{
    xy = h.xy;
    xz = h.xz;
    yz = h.yz;
    yx = h.yx;
    zx = h.zx;
    zy = h.zy;
    return *this;
}

template <class T>
template <class S>
inline const Shear6<T> &
Shear6<T>::operator = (const Vec3<S> &v)
{
    xy = T (v.x);
    xz = T (v.y);
    yz = T (v.z);
    yx = 0;
    zx = 0;
    zy = 0;
    return *this;
}

template <class T>
template <class S>
inline void
Shear6<T>::setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY)
{
    xy = T (XY);
    xz = T (XZ);
    yz = T (YZ);
    yx = T (YX);
    zx = T (ZX);
    zy = T (ZY);
}

template <class T>
template <class S>
inline void
Shear6<T>::setValue (const Shear6<S> &h)
{
    xy = T (h.xy);
    xz = T (h.xz);
    yz = T (h.yz);
    yx = T (h.yx);
    zx = T (h.zx);
    zy = T (h.zy);
}

template <class T>
template <class S>
inline void
Shear6<T>::getValue (S &XY, S &XZ, S &YZ, S &YX, S &ZX, S &ZY) const
{
    XY = S (xy);
    XZ = S (xz);
    YZ = S (yz);
    YX = S (yx);
    ZX = S (zx);
    ZY = S (zy);
}

template <class T>
template <class S>
inline void
Shear6<T>::getValue (Shear6<S> &h) const
{
    h.xy = S (xy);
    h.xz = S (xz);
    h.yz = S (yz);
    h.yx = S (yx);
    h.zx = S (zx);
    h.zy = S (zy);
}

template <class T>
inline T *
Shear6<T>::getValue()
{
    return (T *) &xy;
}

template <class T>
inline const T *
Shear6<T>::getValue() const
{
    return (const T *) &xy;
}

template <class T>
template <class S>
inline bool
Shear6<T>::operator == (const Shear6<S> &h) const
{
    return xy == h.xy  &&  xz == h.xz  &&  yz == h.yz  &&  
	   yx == h.yx  &&  zx == h.zx  &&  zy == h.zy;
}

template <class T>
template <class S>
inline bool
Shear6<T>::operator != (const Shear6<S> &h) const
{
    return xy != h.xy  ||  xz != h.xz  ||  yz != h.yz  ||
	   yx != h.yx  ||  zx != h.zx  ||  zy != h.zy;
}

template <class T>
bool
Shear6<T>::equalWithAbsError (const Shear6<T> &h, T e) const
{
    for (int i = 0; i < 6; i++)
	if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], h[i], e))
	    return false;

return true;
}

template <class T>
bool
Shear6<T>::equalWithRelError (const Shear6<T> &h, T e) const
{
    for (int i = 0; i < 6; i++)
	if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], h[i], e))
	    return false;

return true;
}

template <class T>
inline const Shear6<T> &
Shear6<T>::operator += (const Shear6 &h)
{
    xy += h.xy;
    xz += h.xz;
    yz += h.yz;
    yx += h.yx;
    zx += h.zx;
    zy += h.zy;
    return *this;
}

template <class T>
inline Shear6<T>
Shear6<T>::operator + (const Shear6 &h) const
{
    return Shear6 (xy + h.xy, xz + h.xz, yz + h.yz,
		   yx + h.yx, zx + h.zx, zy + h.zy);
}

template <class T>
inline const Shear6<T> &
Shear6<T>::operator -= (const Shear6 &h)
{
    xy -= h.xy;
    xz -= h.xz;
    yz -= h.yz;
    yx -= h.yx;
    zx -= h.zx;
    zy -= h.zy;
    return *this;
}

template <class T>
inline Shear6<T>
Shear6<T>::operator - (const Shear6 &h) const
{
    return Shear6 (xy - h.xy, xz - h.xz, yz - h.yz,
		   yx - h.yx, zx - h.zx, zy - h.zy);
}

template <class T>
inline Shear6<T>
Shear6<T>::operator - () const
{
    return Shear6 (-xy, -xz, -yz, -yx, -zx, -zy);
}

template <class T>
inline const Shear6<T> &
Shear6<T>::negate ()
{
    xy = -xy;
    xz = -xz;
    yz = -yz;
    yx = -yx;
    zx = -zx;
    zy = -zy;
    return *this;
}

template <class T>
inline const Shear6<T> &
Shear6<T>::operator *= (const Shear6 &h)
{
    xy *= h.xy;
    xz *= h.xz;
    yz *= h.yz;
    yx *= h.yx;
    zx *= h.zx;
    zy *= h.zy;
    return *this;
}

template <class T>
inline const Shear6<T> &
Shear6<T>::operator *= (T a)
{
    xy *= a;
    xz *= a;
    yz *= a;
    yx *= a;
    zx *= a;
    zy *= a;
    return *this;
}

template <class T>
inline Shear6<T>
Shear6<T>::operator * (const Shear6 &h) const
{
    return Shear6 (xy * h.xy, xz * h.xz, yz * h.yz, 
		   yx * h.yx, zx * h.zx, zy * h.zy);
}

template <class T>
inline Shear6<T>
Shear6<T>::operator * (T a) const
{
    return Shear6 (xy * a, xz * a, yz * a,
		   yx * a, zx * a, zy * a);
}

template <class T>
inline const Shear6<T> &
Shear6<T>::operator /= (const Shear6 &h)
{
    xy /= h.xy;
    xz /= h.xz;
    yz /= h.yz;
    yx /= h.yx;
    zx /= h.zx;
    zy /= h.zy;
    return *this;
}

template <class T>
inline const Shear6<T> &
Shear6<T>::operator /= (T a)
{
    xy /= a;
    xz /= a;
    yz /= a;
    yx /= a;
    zx /= a;
    zy /= a;
    return *this;
}

template <class T>
inline Shear6<T>
Shear6<T>::operator / (const Shear6 &h) const
{
    return Shear6 (xy / h.xy, xz / h.xz, yz / h.yz,
		   yx / h.yx, zx / h.zx, zy / h.zy);
}

template <class T>
inline Shear6<T>
Shear6<T>::operator / (T a) const
{
    return Shear6 (xy / a, xz / a, yz / a,
		   yx / a, zx / a, zy / a);
}

//-----------------------------
// Stream output implementation
//-----------------------------

template <class T>
std::ostream &
operator << (std::ostream &s, const Shear6<T> &h)
{
    return s << '(' 
	     << h.xy << ' ' << h.xz << ' ' << h.yz 
	     << h.yx << ' ' << h.zx << ' ' << h.zy 
	     << ')';
}

//-----------------------------------------
// Implementation of reverse multiplication
//-----------------------------------------

template <class S, class T>
inline Shear6<T>
operator * (S a, const Shear6<T> &h)
{
    return Shear6<T> (a * h.xy, a * h.xz, a * h.yz,
		      a * h.yx, a * h.zx, a * h.zy);
}

IMATH_INTERNAL_NAMESPACE_HEADER_EXIT

#endif // INCLUDED_IMATHSHEAR_H