yade-dev team mailing list archive
-
yade-dev team
-
Mailing list archive
-
Message #03403
[Branch ~yade-dev/yade/trunk] Rev 2029: 1. Fix compilation for per-class builds
------------------------------------------------------------
revno: 2029
committer: Václav Šmilauer <eudoxos@xxxxxxxx>
branch nick: trunk
timestamp: Mon 2010-02-15 20:27:34 +0100
message:
1. Fix compilation for per-class builds
2. Add manual wrapper for wm3 classes instead of the auto-generated one, to ease transition to eigen. Let me know if it broke something.
added:
py/miniWm3Wrap/manualWrap.cpp
modified:
pkg/common/Engine/PartialEngine/GravityEngines.hpp
py/SConscript
py/miniWm3Wrap/miniWm3Wrap-generate.py
py/miniWm3Wrap/miniWm3Wrap.cpp
--
lp:yade
https://code.launchpad.net/~yade-dev/yade/trunk
Your team Yade developers is subscribed to branch lp:yade.
To unsubscribe from this branch go to https://code.launchpad.net/~yade-dev/yade/trunk/+edit-subscription.
=== modified file 'pkg/common/Engine/PartialEngine/GravityEngines.hpp'
--- pkg/common/Engine/PartialEngine/GravityEngines.hpp 2010-02-09 16:50:30 +0000
+++ pkg/common/Engine/PartialEngine/GravityEngines.hpp 2010-02-15 19:27:34 +0000
@@ -3,6 +3,7 @@
#pragma once
#include<yade/core/GlobalEngine.hpp>
#include<yade/core/Interaction.hpp>
+#include<yade/core/Body.hpp>
/*! Homogeneous gravity field; applies gravity×mass force on all bodies. */
class GravityEngine: public GlobalEngine{
=== modified file 'py/SConscript'
--- py/SConscript 2010-01-21 13:50:32 +0000
+++ py/SConscript 2010-02-15 19:27:34 +0000
@@ -46,7 +46,8 @@
# 3rd party modules:
# ==================
env.Install('$PREFIX/lib/yade$SUFFIX/py',[
- env.SharedLibrary('miniWm3Wrap',['miniWm3Wrap/miniWm3Wrap.cpp'],SHLIBPREFIX='',CPPPATH=env['CPPPATH']+['../lib/'],LIBS=env['LIBS']+['core']),
+ #env.SharedLibrary('miniWm3Wrap',['miniWm3Wrap/miniWm3Wrap.cpp'],SHLIBPREFIX='',CPPPATH=env['CPPPATH']+['../lib/'],LIBS=env['LIBS']+['core']),
+ env.SharedLibrary('miniWm3Wrap',['miniWm3Wrap/manualWrap.cpp'],SHLIBPREFIX='',CPPPATH=env['CPPPATH']+['../lib/'],LIBS=env['LIBS']+['core']),
])
if 'YADE_GTS' in env['CPPDEFINES']:
=== added file 'py/miniWm3Wrap/manualWrap.cpp'
--- py/miniWm3Wrap/manualWrap.cpp 1970-01-01 00:00:00 +0000
+++ py/miniWm3Wrap/manualWrap.cpp 2010-02-15 19:27:34 +0000
@@ -0,0 +1,209 @@
+// 2009 © Václav Šmilauer <eudoxos@xxxxxxxx>
+#include<boost/python.hpp>
+#include<boost/lexical_cast.hpp>
+#include<string>
+#include<stdexcept>
+#include<sstream>
+
+#include<yade/lib-base/Math.hpp>
+
+namespace bp=boost::python;
+
+#define IDX_CHECK(i,MAX){ if(i<0 || i>=MAX) { PyErr_SetString(PyExc_IndexError, ("Index out of range 0.." + boost::lexical_cast<std::string>(MAX-1)).c_str()); bp::throw_error_already_set(); } }
+#define IDX2_CHECKED_TUPLE_INTS(tuple,max2,arr2) {int l=bp::len(tuple); if(l!=2) { PyErr_SetString(PyExc_IndexError,"Index must be integer or a 2-tuple"); bp::throw_error_already_set(); } for(int _i=0; _i<2; _i++) { bp::extract<int> val(tuple[_i]); if(!val.check()) throw std::runtime_error("Unable to convert "+boost::lexical_cast<std::string>(_i)+"-th index to int."); int v=val(); IDX_CHECK(v,max2[_i]); arr2[_i]=v; } }
+
+void Vector2_set_item(Vector2r & self, int idx, Real value){ IDX_CHECK(idx,2); self[idx]=value; }
+void Vector3_set_item(Vector3r & self, int idx, Real value){ IDX_CHECK(idx,3); self[idx]=value; }
+void Quaternion_set_item(Quaternionr & self, int idx, Real value){ IDX_CHECK(idx,4); self[idx]=value; }
+void Matrix3_set_item(Matrix3r & self, bp::tuple _idx, Real value){ int idx[2]; int mx[2]={3,3}; IDX2_CHECKED_TUPLE_INTS(_idx,mx,idx); self(idx[0],idx[1])=value; }
+void Matrix3_set_item_linear(Matrix3r & self, int idx, Real value){ IDX_CHECK(idx,9); self(idx/3,idx%3)=value; }
+
+Real Vector2_get_item(const Vector2r & self, int idx){ IDX_CHECK(idx,2); return self[idx]; }
+Real Vector3_get_item(const Vector3r & self, int idx){ IDX_CHECK(idx,3); return self[idx]; }
+Real Quaternion_get_item(const Quaternionr & self, int idx){ IDX_CHECK(idx,4); return self[idx]; }
+Real Matrix3_get_item(Matrix3r & self, bp::tuple _idx){ int idx[2]; int mx[2]={3,3}; IDX2_CHECKED_TUPLE_INTS(_idx,mx,idx); return self(idx[0],idx[1]); }
+Real Matrix3_get_item_linear(Matrix3r & self, int idx){ IDX_CHECK(idx,9); return self(idx/3,idx%3); }
+
+std::string Vector2_str(const Vector2r & self){ return std::string("Vector2(")+boost::lexical_cast<std::string>(self[0])+","+boost::lexical_cast<std::string>(self[1])+")";}
+std::string Vector3_str(const Vector3r & self){ return std::string("Vector3(")+boost::lexical_cast<std::string>(self[0])+","+boost::lexical_cast<std::string>(self[1])+","+boost::lexical_cast<std::string>(self[2])+")";}
+std::string Quaternion_str(const Quaternionr & self){ Vector3r axis; Real angle; self.ToAxisAngle(axis,angle); return std::string("Quaternion((")+boost::lexical_cast<std::string>(axis[0])+","+boost::lexical_cast<std::string>(axis[1])+","+boost::lexical_cast<std::string>(axis[2])+"),"+boost::lexical_cast<std::string>(angle)+")";}
+std::string Matrix3_str(const Matrix3r & self){ std::ostringstream oss; oss<<"Matrix3("; for(int i=0; i<3; i++) for(int j=0; j<3; j++) oss<<self(i,j)<<((i==2 && j==2)?")":",")<<((i<2 && j==2)?" ":""); return oss.str(); }
+
+int Vector2_len(){return 2;}
+int Vector3_len(){return 3;}
+int Quaternion_len(){return 4;}
+int Matrix3_len(){return 9;}
+#undef IDX_CHECK
+
+#if 1
+ // workarounds for static methods; disabled for now, see comment in miniWm3Wrap-generate.py
+ #define _WORKAROUND(clss,member) clss clss##_##member(const clss& self){return clss::member;}
+ _WORKAROUND(Vector2r,ONE); _WORKAROUND(Vector2r,UNIT_X); _WORKAROUND(Vector2r,UNIT_Y); _WORKAROUND(Vector2r,ZERO);
+ _WORKAROUND(Vector3r,ONE); _WORKAROUND(Vector3r,UNIT_X); _WORKAROUND(Vector3r,UNIT_Y); _WORKAROUND(Vector3r,UNIT_Z); _WORKAROUND(Vector3r,ZERO);
+ _WORKAROUND(Quaternionr,IDENTITY); _WORKAROUND(Quaternionr,ZERO);
+ _WORKAROUND(Matrix3r,IDENTITY); _WORKAROUND(Matrix3r,ZERO);
+ #undef _WORKAROUND
+#endif
+
+// automagic converter from tuple to Vector3r
+struct custom_Vector3r_from_tuple{
+ custom_Vector3r_from_tuple(){
+ bp::converter::registry::push_back(&convertible,&construct,bp::type_id<Vector3r>());
+ }
+ static void* convertible(PyObject* obj_ptr){
+ if(!PySequence_Check(obj_ptr) || PySequence_Size(obj_ptr)!=3) return 0;
+ return obj_ptr;
+ }
+ static void construct(PyObject* obj_ptr, bp::converter::rvalue_from_python_stage1_data* data){
+ void* storage=((bp::converter::rvalue_from_python_storage<Vector3r>*)(data))->storage.bytes;
+ new (storage) Vector3r(bp::extract<Real>(PySequence_GetItem(obj_ptr,0)),bp::extract<Real>(PySequence_GetItem(obj_ptr,1)),bp::extract<Real>(PySequence_GetItem(obj_ptr,2)));
+ data->convertible=storage;
+ }
+};
+
+
+static bp::tuple Quaternion_ToAxisAngle(const Quaternionr& q){
+ Vector3r axis; Real angle;
+ q.ToAxisAngle(axis,angle);
+ return bp::make_tuple(axis,angle);
+}
+
+BOOST_PYTHON_MODULE(miniWm3Wrap){
+ bp::class_<Matrix3r >("Matrix3",bp::init<bp::optional<bool> >((bp::arg("zero")=true)))
+ .def(bp::init<Matrix3r const &>((bp::arg("m"))))
+ .def(bp::init<Real,Real,Real,Real,Real,Real,Real,Real,Real>((bp::arg("n00"),bp::arg("n01"),bp::arg("n02"),bp::arg("n10"),bp::arg("n11"),bp::arg("n12"),bp::arg("n20"),bp::arg("n21"),bp::arg("n22"))))
+ // .def(bp::init<const Vector3r&, const Vector3r&, const Vector3r&, bool>((bp::arg("v0"),bp::arg("v1"),bp::arg("v2"),bp::arg("columns"))))
+ .def(bp::init<Real,Real,Real>((bp::arg("n00"),bp::arg("n11"),bp::arg("n22"))))
+ //.def(bp::init<Vector3r>((bp::arg("diag"))))
+ .def("Determinant",&Matrix3r::Determinant)
+ .def("Inverse",&Matrix3r::Inverse)
+ .def("Transpose",&Matrix3r::Transpose)
+ .def(bp::self * bp::self)
+ //.def(bp::self *= bp::self)
+ .def(bp::self + bp::self)
+ .def(bp::self += bp::self)
+ .def(bp::self - bp::self)
+ .def(bp::self -= bp::self)
+ .def(bp::self * bp::other<Real>())
+ .def(bp::other<Real>() * bp::self)
+ .def(bp::self *= bp::other<Real>())
+ .def(bp::self / bp::other<Real>())
+ .def(bp::self /= bp::other<Real>())
+ .def(bp::self == bp::self)
+ .def(bp::self != bp::self)
+ .def(-bp::self)
+ .def("__len__",&::Matrix3_len).staticmethod("__len__")
+ .def("__setitem__",&::Matrix3_set_item)
+ .def("__getitem__",&::Matrix3_get_item)
+ .def("__str__",&::Matrix3_str)
+ .def("__repr__",&::Matrix3_str)
+ /* extras for matrices */
+ .def("__setitem__",&::Matrix3_set_item_linear)
+ .def("__getitem__",&::Matrix3_get_item_linear)
+ .def_readonly("IDENTITY",Matrix3r::IDENTITY)
+ .def_readonly("ZERO",Matrix3r::ZERO)
+ ;
+ bp::class_<Quaternionr>("Quaternion",bp::init<>())
+ .def(bp::init<Vector3r,Real>((bp::arg("axis"),bp::arg("angle"))))
+ //.def(bp::init<Matrix3r>((bp::arg("rotMatrix"))))
+ .def(bp::init<Quaternionr>((bp::arg("other"))))
+ .def("Align",&Quaternionr::Align,((bp::arg("v1"),bp::arg("v2"))))
+ .def("Conjugate",&Quaternionr::Conjugate)
+ .def("FromAxisAngle",&Quaternionr::FromAxisAngle,((bp::arg("axis"),bp::arg("angle"))))
+ .def("Inverse",&Quaternionr::Inverse)
+ .def("Length",&Quaternionr::Length)
+ .def("Normalize",&Quaternionr::Normalize)
+ .def("ToRotationMatrix",&Quaternionr::ToRotationMatrix)
+ .def("ToAxisAngle",Quaternion_ToAxisAngle)
+ .def(bp::self != bp::self)
+ .def(bp::self == bp::self)
+ .def(bp::self * bp::self)
+ .def(bp::self * bp::other<Real>())
+ .def(bp::other<Real>() * bp::self)
+ .def(bp::self * bp::other<Vector3r>())
+ //.def(bp::self *= bp::other<Real>())
+ .def(bp::self + bp::self)
+ .def(bp::self += bp::self)
+ //.def(bp::self - bp::self)
+ //.def(-bp::self)
+ //.def(bp::self -= bp::self)
+ //.def(bp::self / bp::other<Real>())
+ //.def(bp::self /= bp::other<Real>())
+ .def("__len__",&::Quaternion_len).staticmethod("__len__")
+ .def("__setitem__",&::Quaternion_set_item)
+ .def("__getitem__",&::Quaternion_get_item)
+ .def("__str__",&::Quaternion_str)
+ .def("__repr__",&::Quaternion_str)
+ .def_readonly("IDENTITY",Matrix3r::IDENTITY)
+ .def_readonly("ZERO",Matrix3r::ZERO)
+ ;
+ bp::class_<Vector2r>("Vector2",bp::init<>())
+ .def(bp::init<Vector2r>((bp::arg("other"))))
+ .def(bp::init<Real,Real>((bp::arg("x"),bp::arg("y"))))
+ .def("Dot",&Vector2r::Dot)
+ .def("Length",&Vector2r::Length)
+ .def("SquaredLength",&Vector2r::SquaredLength)
+ .def("Normalize",&Vector2r::Normalize)
+ .def(bp::self != bp::self)
+ .def(bp::self == bp::self)
+ .def(bp::self * bp::other<Real>())
+ .def(bp::other<Real>() * bp::self)
+ .def(bp::self *= bp::other<Real>())
+ .def(bp::self + bp::self)
+ .def(bp::self += bp::self)
+ .def(bp::self - bp::self)
+ .def(bp::self -= bp::self)
+ .def(-bp::self)
+ .def(bp::self / bp::other<Real>())
+ .def(bp::self /= bp::other<Real>())
+ .def("__len__",&::Vector2_len).staticmethod("__len__")
+ .def("__setitem__",&::Vector2_set_item)
+ .def("__getitem__",&::Vector2_get_item)
+ .def("__str__",&::Vector2_str)
+ .def("__repr__",&::Vector2_str)
+ .def_readonly("ONE",Vector2r::ONE)
+ .def_readonly("UNIT_X",Vector2r::UNIT_X)
+ .def_readonly("UNIT_Y",Vector2r::UNIT_Y)
+ .def_readonly("ZERO",Vector2r::ZERO)
+ ;
+ bp::class_<Vector3r>("Vector3",bp::init<>())
+ .def(bp::init<Vector3r>((bp::arg("other"))))
+ .def(bp::init<Real,Real,Real>((bp::arg("x"),bp::arg("y"),bp::arg("z"))))
+ .def("Dot",&Vector3r::Dot)
+ .def("Cross",&Vector3r::Cross)
+ .def("Length",&Vector3r::Length)
+ .def("SquaredLength",&Vector3r::SquaredLength)
+ .def("Normalize",&Vector3r::Normalize)
+ .def(bp::self != bp::self)
+ .def(bp::self == bp::self)
+ .def(bp::self * bp::other<Real>())
+ .def(bp::other<Real>() * bp::self)
+ .def(bp::self *= bp::other<Real>())
+ .def(bp::self + bp::self)
+ .def(bp::self += bp::self)
+ .def(bp::self - bp::self)
+ .def(bp::self -= bp::self)
+ .def(-bp::self)
+ .def(bp::self / bp::other<Real>())
+ .def(bp::self /= bp::other<Real>())
+ .def("__len__",&::Vector3_len).staticmethod("__len__")
+ .def("__setitem__",&::Vector3_set_item)
+ .def("__getitem__",&::Vector3_get_item)
+ .def("__str__",&::Vector3_str)
+ .def("__repr__",&::Vector3_str)
+ .def_readonly("ONE",Vector3r::ONE)
+ .def_readonly("UNIT_X",Vector3r::UNIT_X)
+ .def_readonly("UNIT_Y",Vector3r::UNIT_Y)
+ .def_readonly("UNIT_Z",Vector3r::UNIT_Z)
+ .def_readonly("ZERO",Vector3r::ZERO)
+ ;
+
+};
+
+
+
+
+
+
+
+
=== modified file 'py/miniWm3Wrap/miniWm3Wrap-generate.py'
--- py/miniWm3Wrap/miniWm3Wrap-generate.py 2010-01-22 21:07:37 +0000
+++ py/miniWm3Wrap/miniWm3Wrap-generate.py 2010-02-15 19:27:34 +0000
@@ -12,8 +12,8 @@
#Creating an instance of class that will help you to expose your declarations
mb = module_builder.module_builder_t( [os.path.abspath("miniWm3Wrap-toExpose.hpp")]
, working_directory=r"."
- , include_paths=['../../lib','../../lib/miniWm3','/usr/include']
- , define_symbols=['USE_MINIWM3'] )
+ , include_paths=['../../lib','../../lib/miniWm3','../../../build-trunk-dbg/include/yade-trunk','/usr/include']
+ , define_symbols=['USE_MINIWM3','YADE_EIGEN'] )
# exclude exerything first
mb.decls().exclude()
# include what is in Wm3
@@ -30,8 +30,8 @@
# exclude functions&operators returning double& (not representable)
mb.member_functions(return_type='double &').exclude()
mb.global_ns.operators(return_type='double &').exclude() # global_ns is a bug workaround: http://www.mail-archive.com/cplusplus-sig@xxxxxxxxxx/msg00730.html
-# exclude everything (member functions, operators, ...) taking or returning types we do not wrap
-mb.decls(lambda d: 'Matrix2' in str(d) or 'Vector4' in str(d)).exclude()
+## exclude everything (member functions, operators, ...) taking or returning types we do not wrap
+## mb.decls(lambda d: 'Matrix2' in str(d) or 'Vector4' in str(d)).exclude()
# exclude operator[] since we implement __getitem__/__setitem__ by ourselves
mb.member_operators(lambda o: o.symbol=='[]').exclude()
# exclude From/To Euler angles, since we don't need it
@@ -40,6 +40,17 @@
mb.decls(lambda d: d.name in ('componentMaxVector','componentMinVector','componentSum','diagDiv','diagMult','quaternionFromAxes','quaternionToAxes','quaternionToEulerAngles','quaterniontoGLMatrix','unitVectorsAngle')).exclude()
+## exclude what is not in the wm3-eigen glue
+if 1:
+ undef="""
+Adjoint DiagonalTimes GetColumnMajor Orthonormalize QDUDecomposition QForm SingularValueComposition SingularValueDecomposition Slerp TimesDiagonal TimesTranspose TransposeTimes MakeTensorProduct
+DecomposeSwingTimesTwist DecomposeTwistTimesSwing Exp FromRotationMatrix Intermediate Log SlerpExtraSpins Squad
+ComputeExtremes DotPerp GenerateOrthonormalBasis GetBarycentrics Orthonormalize Perp UnitPerp
+ComputeExtremes GenerateOrthonormalBasis GetBarycentrics Orthonormalize
+MakeDiagonal MakeZero MakeIdentity""".split()
+ mb.member_functions(lambda d: d.name in undef).exclude()
+
+
# register manual wraps
v2,v3,q4,m3=mb.class_(lambda d: d.name=='Vector2<double>'),mb.class_(lambda d: d.name=='Vector3<double>'),mb.class_(lambda d: d.name=='Quaternion<double>'),mb.class_(lambda d: d.name=='Matrix3<double>')
v2.add_registration_code('def("__len__",&::Vector2_len) .staticmethod("__len__").def("__setitem__",&::Vector2_set_item) .def("__getitem__",&::Vector2_get_item) .def("__str__",&::Vector2_str) .def("__repr__",&::Vector2_str)')
@@ -50,7 +61,7 @@
## workarounds for def_readonly on static members
# disabled, doesn't work on types (e.g. Vector3.ZERO), must pass instance (e.g. Vector3().ZERO)
-if 1:
+if 0:
mb.decls(lambda d: 'UNIT_' in str(d) or 'ZERO' in str(d) or 'IDENTITY' in str(d) or 'ONE' in str(d)).exclude()
v2.add_registration_code('.'.join('add_property("%s",::Vector2r_%s)'%(prop,prop) for prop in ('ZERO','UNIT_X','UNIT_Y','ONE')))
v3.add_registration_code('.'.join('add_property("%s",::Vector3r_%s)'%(prop,prop) for prop in ('ZERO','UNIT_X','UNIT_Y','UNIT_Z','ONE')))
@@ -83,4 +94,7 @@
except IOError: pass
## remove absolute path from the generated file (ugly, oh well)
os.system(r"perl -pi -e 's@^#include\s*\"/.*/(.*)\"\s*$@#include \"\1\"\n@' miniWm3Wrap.cpp")
+os.system(r"perl -pi -e 's@(::)?Wm3::@@g' miniWm3Wrap.cpp")
+os.system(r"perl -pi -e 's@^.*double const \*.*$@@' miniWm3Wrap.cpp")
+os.system(r"perl -pi -e 's@^.*implicitly_convertible.*$@@' miniWm3Wrap.cpp")
=== modified file 'py/miniWm3Wrap/miniWm3Wrap.cpp'
--- py/miniWm3Wrap/miniWm3Wrap.cpp 2010-02-14 21:23:14 +0000
+++ py/miniWm3Wrap/miniWm3Wrap.cpp 2010-02-15 19:27:34 +0000
@@ -31,25 +31,15 @@
typedef bp::class_< Matrix3< double > > Matrix3_exposer_t;
Matrix3_exposer_t Matrix3_exposer = Matrix3_exposer_t( "Matrix3", bp::init< bp::optional< bool > >(( bp::arg("bZero")=(bool)(true) )) );
bp::scope Matrix3_scope( Matrix3_exposer );
- bp::implicitly_convertible< bool, Matrix3< double > >();
+
Matrix3_exposer.def( bp::init< Matrix3< double > const & >(( bp::arg("rkM") )) );
Matrix3_exposer.def( bp::init< double, double, double, double, double, double, double, double, double >(( bp::arg("fM00"), bp::arg("fM01"), bp::arg("fM02"), bp::arg("fM10"), bp::arg("fM11"), bp::arg("fM12"), bp::arg("fM20"), bp::arg("fM21"), bp::arg("fM22") )) );
- Matrix3_exposer.def( bp::init< double const *, bool >(( bp::arg("afEntry"), bp::arg("bRowMajor") )) );
+
Matrix3_exposer.def( bp::init< Vector3< double > const &, Vector3< double > const &, Vector3< double > const &, bool >(( bp::arg("rkU"), bp::arg("rkV"), bp::arg("rkW"), bp::arg("bColumns") )) );
Matrix3_exposer.def( bp::init< Vector3< double > const *, bool >(( bp::arg("akV"), bp::arg("bColumns") )) );
Matrix3_exposer.def( bp::init< double, double, double >(( bp::arg("fM00"), bp::arg("fM11"), bp::arg("fM22") )) );
Matrix3_exposer.def( bp::init< Vector3< double > const &, double >(( bp::arg("rkAxis"), bp::arg("fAngle") )) );
Matrix3_exposer.def( bp::init< Vector3< double > const &, Vector3< double > const & >(( bp::arg("rkU"), bp::arg("rkV") )) );
- { //Matrix3< double >::Adjoint
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > ( exported_class_t::*Adjoint_function_type )( ) const;
-
- Matrix3_exposer.def(
- "Adjoint"
- , Adjoint_function_type( &Matrix3< double >::Adjoint ) );
-
- }
{ //Matrix3< double >::Determinant
typedef Matrix3< double > exported_class_t;
@@ -60,17 +50,6 @@
, Determinant_function_type( &Matrix3< double >::Determinant ) );
}
- { //Matrix3< double >::DiagonalTimes
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > ( exported_class_t::*DiagonalTimes_function_type )( Vector3< double > const & ) const;
-
- Matrix3_exposer.def(
- "DiagonalTimes"
- , DiagonalTimes_function_type( &Matrix3< double >::DiagonalTimes )
- , ( bp::arg("rkDiag") ) );
-
- }
{ //Matrix3< double >::EigenDecomposition
typedef Matrix3< double > exported_class_t;
@@ -105,17 +84,6 @@
, ( bp::arg("iCol") ) );
}
- { //Matrix3< double >::GetColumnMajor
-
- typedef Matrix3< double > exported_class_t;
- typedef void ( exported_class_t::*GetColumnMajor_function_type )( double * ) const;
-
- Matrix3_exposer.def(
- "GetColumnMajor"
- , GetColumnMajor_function_type( &Matrix3< double >::GetColumnMajor )
- , ( bp::arg("afCMajor") ) );
-
- }
{ //Matrix3< double >::GetRow
typedef Matrix3< double > exported_class_t;
@@ -137,84 +105,6 @@
, Inverse_function_type( &Matrix3< double >::Inverse ) );
}
- { //Matrix3< double >::MakeDiagonal
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > & ( exported_class_t::*MakeDiagonal_function_type )( double,double,double ) ;
-
- Matrix3_exposer.def(
- "MakeDiagonal"
- , MakeDiagonal_function_type( &Matrix3< double >::MakeDiagonal )
- , ( bp::arg("fM00"), bp::arg("fM11"), bp::arg("fM22") )
- , bp::return_self< >() );
-
- }
- { //Matrix3< double >::MakeIdentity
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > & ( exported_class_t::*MakeIdentity_function_type )( ) ;
-
- Matrix3_exposer.def(
- "MakeIdentity"
- , MakeIdentity_function_type( &Matrix3< double >::MakeIdentity )
- , bp::return_self< >() );
-
- }
- { //Matrix3< double >::MakeTensorProduct
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > & ( exported_class_t::*MakeTensorProduct_function_type )( Vector3< double > const &,Vector3< double > const & ) ;
-
- Matrix3_exposer.def(
- "MakeTensorProduct"
- , MakeTensorProduct_function_type( &Matrix3< double >::MakeTensorProduct )
- , ( bp::arg("rkU"), bp::arg("rkV") )
- , bp::return_self< >() );
-
- }
- { //Matrix3< double >::MakeZero
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > & ( exported_class_t::*MakeZero_function_type )( ) ;
-
- Matrix3_exposer.def(
- "MakeZero"
- , MakeZero_function_type( &Matrix3< double >::MakeZero )
- , bp::return_self< >() );
-
- }
- { //Matrix3< double >::Orthonormalize
-
- typedef Matrix3< double > exported_class_t;
- typedef void ( exported_class_t::*Orthonormalize_function_type )( ) ;
-
- Matrix3_exposer.def(
- "Orthonormalize"
- , Orthonormalize_function_type( &Matrix3< double >::Orthonormalize ) );
-
- }
- { //Matrix3< double >::QDUDecomposition
-
- typedef Matrix3< double > exported_class_t;
- typedef void ( exported_class_t::*QDUDecomposition_function_type )( Matrix3< double > &,Matrix3< double > &,Matrix3< double > & ) const;
-
- Matrix3_exposer.def(
- "QDUDecomposition"
- , QDUDecomposition_function_type( &Matrix3< double >::QDUDecomposition )
- , ( bp::arg("rkQ"), bp::arg("rkD"), bp::arg("rkU") ) );
-
- }
- { //Matrix3< double >::QForm
-
- typedef Matrix3< double > exported_class_t;
- typedef double ( exported_class_t::*QForm_function_type )( Vector3< double > const &,Vector3< double > const & ) const;
-
- Matrix3_exposer.def(
- "QForm"
- , QForm_function_type( &Matrix3< double >::QForm )
- , ( bp::arg("rkU"), bp::arg("rkV") ) );
-
- }
{ //Matrix3< double >::SetColumn
typedef Matrix3< double > exported_class_t;
@@ -237,61 +127,6 @@
, ( bp::arg("iRow"), bp::arg("rkV") ) );
}
- { //Matrix3< double >::SingularValueComposition
-
- typedef Matrix3< double > exported_class_t;
- typedef void ( exported_class_t::*SingularValueComposition_function_type )( Matrix3< double > const &,Matrix3< double > const &,Matrix3< double > const & ) ;
-
- Matrix3_exposer.def(
- "SingularValueComposition"
- , SingularValueComposition_function_type( &Matrix3< double >::SingularValueComposition )
- , ( bp::arg("rkL"), bp::arg("rkS"), bp::arg("rkR") ) );
-
- }
- { //Matrix3< double >::SingularValueDecomposition
-
- typedef Matrix3< double > exported_class_t;
- typedef void ( exported_class_t::*SingularValueDecomposition_function_type )( Matrix3< double > &,Matrix3< double > &,Matrix3< double > & ) const;
-
- Matrix3_exposer.def(
- "SingularValueDecomposition"
- , SingularValueDecomposition_function_type( &Matrix3< double >::SingularValueDecomposition )
- , ( bp::arg("rkL"), bp::arg("rkS"), bp::arg("rkR") ) );
-
- }
- { //Matrix3< double >::Slerp
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > ( *Slerp_function_type )( double,Matrix3< double > const &,Matrix3< double > const & );
-
- Matrix3_exposer.def(
- "Slerp"
- , Slerp_function_type( &Matrix3< double >::Slerp )
- , ( bp::arg("fT"), bp::arg("rkR0"), bp::arg("rkR1") ) );
-
- }
- { //Matrix3< double >::TimesDiagonal
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > ( exported_class_t::*TimesDiagonal_function_type )( Vector3< double > const & ) const;
-
- Matrix3_exposer.def(
- "TimesDiagonal"
- , TimesDiagonal_function_type( &Matrix3< double >::TimesDiagonal )
- , ( bp::arg("rkDiag") ) );
-
- }
- { //Matrix3< double >::TimesTranspose
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > ( exported_class_t::*TimesTranspose_function_type )( Matrix3< double > const & ) const;
-
- Matrix3_exposer.def(
- "TimesTranspose"
- , TimesTranspose_function_type( &Matrix3< double >::TimesTranspose )
- , ( bp::arg("rkM") ) );
-
- }
{ //Matrix3< double >::ToAxisAngle
typedef Matrix3< double > exported_class_t;
@@ -313,17 +148,6 @@
, Transpose_function_type( &Matrix3< double >::Transpose ) );
}
- { //Matrix3< double >::TransposeTimes
-
- typedef Matrix3< double > exported_class_t;
- typedef Matrix3< double > ( exported_class_t::*TransposeTimes_function_type )( Matrix3< double > const & ) const;
-
- Matrix3_exposer.def(
- "TransposeTimes"
- , TransposeTimes_function_type( &Matrix3< double >::TransposeTimes )
- , ( bp::arg("rkM") ) );
-
- }
Matrix3_exposer.def( bp::self != bp::self );
{ //Matrix3< double >::operator()
@@ -364,10 +188,10 @@
Matrix3_exposer.def( bp::self == bp::self );
Matrix3_exposer.def( bp::self > bp::self );
Matrix3_exposer.def( bp::self >= bp::self );
- Matrix3_exposer.staticmethod( "Slerp" );
+ Matrix3_exposer.def_readonly( "IDENTITY", Matrix3< double >::IDENTITY );
+ Matrix3_exposer.def_readonly( "ZERO", Matrix3< double >::ZERO );
Matrix3_exposer.def( bp::other< Real >() * bp::self );
Matrix3_exposer.def("__len__",&::Matrix3_len).staticmethod("__len__") .def("__setitem__",&::Matrix3_set_item) .def("__getitem__",&::Matrix3_get_item) .def("__str__",&::Matrix3_str) .def("__repr__",&::Matrix3_str) /* extras for matrices */ .def("__setitem__",&::Matrix3_set_item_linear).def("__getitem__",&::Matrix3_get_item_linear);
- Matrix3_exposer.add_property("ZERO",::Matrix3r_ZERO).add_property("IDENTITY",::Matrix3r_IDENTITY);
}
{ //Quaternion< double >
@@ -377,10 +201,10 @@
Quaternion_exposer.def( bp::init< double, double, double, double >(( bp::arg("fW"), bp::arg("fX"), bp::arg("fY"), bp::arg("fZ") )) );
Quaternion_exposer.def( bp::init< Quaternion< double > const & >(( bp::arg("rkQ") )) );
Quaternion_exposer.def( bp::init< Matrix3< double > const & >(( bp::arg("rkRot") )) );
- bp::implicitly_convertible< Matrix3< double > const &, Quaternion< double > >();
+
Quaternion_exposer.def( bp::init< Vector3< double > const &, double >(( bp::arg("rkAxis"), bp::arg("fAngle") )) );
Quaternion_exposer.def( bp::init< Vector3< double > const * >(( bp::arg("akRotColumn") )) );
- bp::implicitly_convertible< Vector3< double > const *, Quaternion< double > >();
+
{ //Quaternion< double >::Align
typedef Quaternion< double > exported_class_t;
@@ -403,28 +227,6 @@
, Conjugate_function_type( &Quaternion< double >::Conjugate ) );
}
- { //Quaternion< double >::DecomposeSwingTimesTwist
-
- typedef Quaternion< double > exported_class_t;
- typedef void ( exported_class_t::*DecomposeSwingTimesTwist_function_type )( Vector3< double > const &,Quaternion< double > &,Quaternion< double > & ) ;
-
- Quaternion_exposer.def(
- "DecomposeSwingTimesTwist"
- , DecomposeSwingTimesTwist_function_type( &Quaternion< double >::DecomposeSwingTimesTwist )
- , ( bp::arg("rkV1"), bp::arg("rkSwing"), bp::arg("rkTwist") ) );
-
- }
- { //Quaternion< double >::DecomposeTwistTimesSwing
-
- typedef Quaternion< double > exported_class_t;
- typedef void ( exported_class_t::*DecomposeTwistTimesSwing_function_type )( Vector3< double > const &,Quaternion< double > &,Quaternion< double > & ) ;
-
- Quaternion_exposer.def(
- "DecomposeTwistTimesSwing"
- , DecomposeTwistTimesSwing_function_type( &Quaternion< double >::DecomposeTwistTimesSwing )
- , ( bp::arg("rkV1"), bp::arg("rkTwist"), bp::arg("rkSwing") ) );
-
- }
{ //Quaternion< double >::Dot
typedef Quaternion< double > exported_class_t;
@@ -436,16 +238,6 @@
, ( bp::arg("rkQ") ) );
}
- { //Quaternion< double >::Exp
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > ( exported_class_t::*Exp_function_type )( ) const;
-
- Quaternion_exposer.def(
- "Exp"
- , Exp_function_type( &Quaternion< double >::Exp ) );
-
- }
{ //Quaternion< double >::FromAxisAngle
typedef Quaternion< double > exported_class_t;
@@ -458,42 +250,6 @@
, bp::return_self< >() );
}
- { //Quaternion< double >::FromRotationMatrix
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > & ( exported_class_t::*FromRotationMatrix_function_type )( Matrix3< double > const & ) ;
-
- Quaternion_exposer.def(
- "FromRotationMatrix"
- , FromRotationMatrix_function_type( &Quaternion< double >::FromRotationMatrix )
- , ( bp::arg("rkRot") )
- , bp::return_self< >() );
-
- }
- { //Quaternion< double >::FromRotationMatrix
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > & ( exported_class_t::*FromRotationMatrix_function_type )( Vector3< double > const * ) ;
-
- Quaternion_exposer.def(
- "FromRotationMatrix"
- , FromRotationMatrix_function_type( &Quaternion< double >::FromRotationMatrix )
- , ( bp::arg("akRotColumn") )
- , bp::return_self< >() );
-
- }
- { //Quaternion< double >::Intermediate
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > & ( exported_class_t::*Intermediate_function_type )( Quaternion< double > const &,Quaternion< double > const &,Quaternion< double > const & ) ;
-
- Quaternion_exposer.def(
- "Intermediate"
- , Intermediate_function_type( &Quaternion< double >::Intermediate )
- , ( bp::arg("rkQ0"), bp::arg("rkQ1"), bp::arg("rkQ2") )
- , bp::return_self< >() );
-
- }
{ //Quaternion< double >::Inverse
typedef Quaternion< double > exported_class_t;
@@ -514,16 +270,6 @@
, Length_function_type( &Quaternion< double >::Length ) );
}
- { //Quaternion< double >::Log
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > ( exported_class_t::*Log_function_type )( ) const;
-
- Quaternion_exposer.def(
- "Log"
- , Log_function_type( &Quaternion< double >::Log ) );
-
- }
{ //Quaternion< double >::Normalize
typedef Quaternion< double > exported_class_t;
@@ -545,42 +291,6 @@
, ( bp::arg("rkVector") ) );
}
- { //Quaternion< double >::Slerp
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > & ( exported_class_t::*Slerp_function_type )( double,Quaternion< double > const &,Quaternion< double > const & ) ;
-
- Quaternion_exposer.def(
- "Slerp"
- , Slerp_function_type( &Quaternion< double >::Slerp )
- , ( bp::arg("fT"), bp::arg("rkP"), bp::arg("rkQ") )
- , bp::return_self< >() );
-
- }
- { //Quaternion< double >::SlerpExtraSpins
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > & ( exported_class_t::*SlerpExtraSpins_function_type )( double,Quaternion< double > const &,Quaternion< double > const &,int ) ;
-
- Quaternion_exposer.def(
- "SlerpExtraSpins"
- , SlerpExtraSpins_function_type( &Quaternion< double >::SlerpExtraSpins )
- , ( bp::arg("fT"), bp::arg("rkP"), bp::arg("rkQ"), bp::arg("iExtraSpins") )
- , bp::return_self< >() );
-
- }
- { //Quaternion< double >::Squad
-
- typedef Quaternion< double > exported_class_t;
- typedef Quaternion< double > & ( exported_class_t::*Squad_function_type )( double,Quaternion< double > const &,Quaternion< double > const &,Quaternion< double > const &,Quaternion< double > const & ) ;
-
- Quaternion_exposer.def(
- "Squad"
- , Squad_function_type( &Quaternion< double >::Squad )
- , ( bp::arg("fT"), bp::arg("rkQ0"), bp::arg("rkA0"), bp::arg("rkA1"), bp::arg("rkQ1") )
- , bp::return_self< >() );
-
- }
{ //Quaternion< double >::SquaredLength
typedef Quaternion< double > exported_class_t;
@@ -692,10 +402,11 @@
Quaternion_exposer.def( bp::self == bp::self );
Quaternion_exposer.def( bp::self > bp::self );
Quaternion_exposer.def( bp::self >= bp::self );
+ Quaternion_exposer.def_readonly( "IDENTITY", Quaternion< double >::IDENTITY );
+ Quaternion_exposer.def_readonly( "ZERO", Quaternion< double >::ZERO );
Quaternion_exposer.def( bp::self * bp::other< Vector3< double > >() );
Quaternion_exposer.def( bp::self_ns::str( bp::self ) );
Quaternion_exposer.def("__len__",&::Quaternion_len).staticmethod("__len__").def("__setitem__",&::Quaternion_set_item).def("__getitem__",&::Quaternion_get_item).def("__str__",&::Quaternion_str).def("__repr__",&::Quaternion_str);
- Quaternion_exposer.add_property("ZERO",::Quaternionr_ZERO).add_property("IDENTITY",::Quaternionr_IDENTITY);
}
{ //Vector2< double >
@@ -703,20 +414,9 @@
Vector2_exposer_t Vector2_exposer = Vector2_exposer_t( "Vector2", bp::init< >() );
bp::scope Vector2_scope( Vector2_exposer );
Vector2_exposer.def( bp::init< double, double >(( bp::arg("fX"), bp::arg("fY") )) );
- Vector2_exposer.def( bp::init< double const * >(( bp::arg("afTuple") )) );
- bp::implicitly_convertible< double const *, Vector2< double > >();
+
+
Vector2_exposer.def( bp::init< Vector2< double > const & >(( bp::arg("rkV") )) );
- { //Vector2< double >::ComputeExtremes
-
- typedef Vector2< double > exported_class_t;
- typedef void ( *ComputeExtremes_function_type )( int,Vector2< double > const *,Vector2< double > &,Vector2< double > & );
-
- Vector2_exposer.def(
- "ComputeExtremes"
- , ComputeExtremes_function_type( &Vector2< double >::ComputeExtremes )
- , ( bp::arg("iVQuantity"), bp::arg("akPoint"), bp::arg("rkMin"), bp::arg("rkMax") ) );
-
- }
{ //Vector2< double >::Dot
typedef Vector2< double > exported_class_t;
@@ -728,39 +428,6 @@
, ( bp::arg("rkV") ) );
}
- { //Vector2< double >::DotPerp
-
- typedef Vector2< double > exported_class_t;
- typedef double ( exported_class_t::*DotPerp_function_type )( Vector2< double > const & ) const;
-
- Vector2_exposer.def(
- "DotPerp"
- , DotPerp_function_type( &Vector2< double >::DotPerp )
- , ( bp::arg("rkV") ) );
-
- }
- { //Vector2< double >::GenerateOrthonormalBasis
-
- typedef Vector2< double > exported_class_t;
- typedef void ( *GenerateOrthonormalBasis_function_type )( Vector2< double > &,Vector2< double > &,bool );
-
- Vector2_exposer.def(
- "GenerateOrthonormalBasis"
- , GenerateOrthonormalBasis_function_type( &Vector2< double >::GenerateOrthonormalBasis )
- , ( bp::arg("rkU"), bp::arg("rkV"), bp::arg("bUnitLengthV") ) );
-
- }
- { //Vector2< double >::GetBarycentrics
-
- typedef Vector2< double > exported_class_t;
- typedef void ( exported_class_t::*GetBarycentrics_function_type )( Vector2< double > const &,Vector2< double > const &,Vector2< double > const &,double * ) const;
-
- Vector2_exposer.def(
- "GetBarycentrics"
- , GetBarycentrics_function_type( &Vector2< double >::GetBarycentrics )
- , ( bp::arg("rkV0"), bp::arg("rkV1"), bp::arg("rkV2"), bp::arg("afBary") ) );
-
- }
{ //Vector2< double >::Length
typedef Vector2< double > exported_class_t;
@@ -781,27 +448,6 @@
, Normalize_function_type( &Vector2< double >::Normalize ) );
}
- { //Vector2< double >::Orthonormalize
-
- typedef Vector2< double > exported_class_t;
- typedef void ( *Orthonormalize_function_type )( Vector2< double > &,Vector2< double > & );
-
- Vector2_exposer.def(
- "Orthonormalize"
- , Orthonormalize_function_type( &Vector2< double >::Orthonormalize )
- , ( bp::arg("rkU"), bp::arg("rkV") ) );
-
- }
- { //Vector2< double >::Perp
-
- typedef Vector2< double > exported_class_t;
- typedef Vector2< double > ( exported_class_t::*Perp_function_type )( ) const;
-
- Vector2_exposer.def(
- "Perp"
- , Perp_function_type( &Vector2< double >::Perp ) );
-
- }
{ //Vector2< double >::SquaredLength
typedef Vector2< double > exported_class_t;
@@ -812,16 +458,6 @@
, SquaredLength_function_type( &Vector2< double >::SquaredLength ) );
}
- { //Vector2< double >::UnitPerp
-
- typedef Vector2< double > exported_class_t;
- typedef Vector2< double > ( exported_class_t::*UnitPerp_function_type )( ) const;
-
- Vector2_exposer.def(
- "UnitPerp"
- , UnitPerp_function_type( &Vector2< double >::UnitPerp ) );
-
- }
{ //Vector2< double >::X
typedef Vector2< double > exported_class_t;
@@ -869,35 +505,22 @@
Vector2_exposer.def( bp::self == bp::self );
Vector2_exposer.def( bp::self > bp::self );
Vector2_exposer.def( bp::self >= bp::self );
- Vector2_exposer.staticmethod( "ComputeExtremes" );
- Vector2_exposer.staticmethod( "GenerateOrthonormalBasis" );
- Vector2_exposer.staticmethod( "Orthonormalize" );
+ Vector2_exposer.def_readonly( "ONE", Vector2< double >::ONE );
+ Vector2_exposer.def_readonly( "UNIT_X", Vector2< double >::UNIT_X );
+ Vector2_exposer.def_readonly( "UNIT_Y", Vector2< double >::UNIT_Y );
+ Vector2_exposer.def_readonly( "ZERO", Vector2< double >::ZERO );
Vector2_exposer.def( bp::other< Real >() * bp::self );
Vector2_exposer.def("__len__",&::Vector2_len) .staticmethod("__len__").def("__setitem__",&::Vector2_set_item) .def("__getitem__",&::Vector2_get_item) .def("__str__",&::Vector2_str) .def("__repr__",&::Vector2_str);
- Vector2_exposer.add_property("ZERO",::Vector2r_ZERO).add_property("UNIT_X",::Vector2r_UNIT_X).add_property("UNIT_Y",::Vector2r_UNIT_Y).add_property("ONE",::Vector2r_ONE);
}
- custom_Vector3r_from_tuple();
-
{ //Vector3< double >
typedef bp::class_< Vector3< double > > Vector3_exposer_t;
Vector3_exposer_t Vector3_exposer = Vector3_exposer_t( "Vector3", bp::init< >() );
bp::scope Vector3_scope( Vector3_exposer );
Vector3_exposer.def( bp::init< double, double, double >(( bp::arg("fX"), bp::arg("fY"), bp::arg("fZ") )) );
- Vector3_exposer.def( bp::init< double const * >(( bp::arg("afTuple") )) );
- bp::implicitly_convertible< double const *, Vector3< double > >();
+
+
Vector3_exposer.def( bp::init< Vector3< double > const & >(( bp::arg("rkV") )) );
- { //Vector3< double >::ComputeExtremes
-
- typedef Vector3< double > exported_class_t;
- typedef void ( *ComputeExtremes_function_type )( int,Vector3< double > const *,Vector3< double > &,Vector3< double > & );
-
- Vector3_exposer.def(
- "ComputeExtremes"
- , ComputeExtremes_function_type( &Vector3< double >::ComputeExtremes )
- , ( bp::arg("iVQuantity"), bp::arg("akPoint"), bp::arg("rkMin"), bp::arg("rkMax") ) );
-
- }
{ //Vector3< double >::Cross
typedef Vector3< double > exported_class_t;
@@ -920,28 +543,6 @@
, ( bp::arg("rkV") ) );
}
- { //Vector3< double >::GenerateOrthonormalBasis
-
- typedef Vector3< double > exported_class_t;
- typedef void ( *GenerateOrthonormalBasis_function_type )( Vector3< double > &,Vector3< double > &,Vector3< double > &,bool );
-
- Vector3_exposer.def(
- "GenerateOrthonormalBasis"
- , GenerateOrthonormalBasis_function_type( &Vector3< double >::GenerateOrthonormalBasis )
- , ( bp::arg("rkU"), bp::arg("rkV"), bp::arg("rkW"), bp::arg("bUnitLengthW") ) );
-
- }
- { //Vector3< double >::GetBarycentrics
-
- typedef Vector3< double > exported_class_t;
- typedef void ( exported_class_t::*GetBarycentrics_function_type )( Vector3< double > const &,Vector3< double > const &,Vector3< double > const &,Vector3< double > const &,double * ) const;
-
- Vector3_exposer.def(
- "GetBarycentrics"
- , GetBarycentrics_function_type( &Vector3< double >::GetBarycentrics )
- , ( bp::arg("rkV0"), bp::arg("rkV1"), bp::arg("rkV2"), bp::arg("rkV3"), bp::arg("afBary") ) );
-
- }
{ //Vector3< double >::Length
typedef Vector3< double > exported_class_t;
@@ -962,28 +563,6 @@
, Normalize_function_type( &Vector3< double >::Normalize ) );
}
- { //Vector3< double >::Orthonormalize
-
- typedef Vector3< double > exported_class_t;
- typedef void ( *Orthonormalize_function_type )( Vector3< double > &,Vector3< double > &,Vector3< double > & );
-
- Vector3_exposer.def(
- "Orthonormalize"
- , Orthonormalize_function_type( &Vector3< double >::Orthonormalize )
- , ( bp::arg("rkU"), bp::arg("rkV"), bp::arg("rkW") ) );
-
- }
- { //Vector3< double >::Orthonormalize
-
- typedef Vector3< double > exported_class_t;
- typedef void ( *Orthonormalize_function_type )( Vector3< double > * );
-
- Vector3_exposer.def(
- "Orthonormalize"
- , Orthonormalize_function_type( &Vector3< double >::Orthonormalize )
- , ( bp::arg("akV") ) );
-
- }
{ //Vector3< double >::SquaredLength
typedef Vector3< double > exported_class_t;
@@ -1062,12 +641,17 @@
Vector3_exposer.def( bp::self == bp::self );
Vector3_exposer.def( bp::self > bp::self );
Vector3_exposer.def( bp::self >= bp::self );
- Vector3_exposer.staticmethod( "ComputeExtremes" );
- Vector3_exposer.staticmethod( "GenerateOrthonormalBasis" );
- Vector3_exposer.staticmethod( "Orthonormalize" );
+ Vector3_exposer.def_readonly( "ONE", Vector3< double >::ONE );
+ Vector3_exposer.def_readonly( "UNIT_X", Vector3< double >::UNIT_X );
+ Vector3_exposer.def_readonly( "UNIT_Y", Vector3< double >::UNIT_Y );
+ Vector3_exposer.def_readonly( "UNIT_Z", Vector3< double >::UNIT_Z );
+ Vector3_exposer.def_readonly( "ZERO", Vector3< double >::ZERO );
Vector3_exposer.def( bp::self * bp::other< Matrix3< double > >() );
Vector3_exposer.def( bp::self_ns::str( bp::self ) );
Vector3_exposer.def("__len__",&::Vector3_len) .staticmethod("__len__").def("__setitem__",&::Vector3_set_item) .def("__getitem__",&::Vector3_get_item) .def("__str__",&::Vector3_str) .def("__repr__",&::Vector3_str);
- Vector3_exposer.add_property("ZERO",::Vector3r_ZERO).add_property("UNIT_X",::Vector3r_UNIT_X).add_property("UNIT_Y",::Vector3r_UNIT_Y).add_property("UNIT_Z",::Vector3r_UNIT_Z).add_property("ONE",::Vector3r_ONE);
}
+
+ custom_Vector3r_from_tuple();
+
+ bp::scope().attr("NaN") = NaN;
}
