mirror of https://github.com/CGAL/cgal
136 lines
3.8 KiB
C++
136 lines
3.8 KiB
C++
#ifndef CGAL_VECTOR_2INT_H
|
|
#define CGAL_VECTOR_2INT_H
|
|
|
|
#include <stdint.h>
|
|
#include <CGAL/array.h>
|
|
#include <CGAL/Dimension.h>
|
|
#include <CGAL/enum.h>
|
|
#include <CGAL/number_utils.h>
|
|
#include <CGAL/NT_converter.h>
|
|
#include <CGAL/transforming_iterator.h>
|
|
#include <CGAL/determinant_of_vectors.h>
|
|
|
|
|
|
|
|
namespace CGAL {
|
|
|
|
struct Vector_2_int {
|
|
#if 1
|
|
typedef double NT; // try lying a bit
|
|
typedef int32_t NT1; // what is really stored
|
|
// (sign_of_)determinant_of_vectors needs adapting for unsigned NT1
|
|
//typedef unsigned int NTu1;
|
|
typedef int_least64_t NT2; // longer type for computations
|
|
//typedef uint_least64_t NTu2;
|
|
#else
|
|
typedef long double NT;
|
|
typedef int64_t NT1;
|
|
//typedef uint64_t NTu1;
|
|
typedef __int128 NT2;
|
|
//typedef unsigned __int128 NTu2;
|
|
#endif
|
|
|
|
typedef Dimension_tag<2> Dimension;
|
|
typedef Dimension_tag<2> Max_dimension;
|
|
// No Rebind_dimension, this is a building block
|
|
template<class,bool=true> struct Property : boost::false_type {};
|
|
//template<bool b> struct Property<Has_vector_plus_minus_tag,b>
|
|
// : boost::true_type {};
|
|
template<bool b> struct Property<Has_determinant_of_vectors_tag,b>
|
|
: boost::true_type {};
|
|
//template<bool b> struct Property<Has_determinant_of_points_tag,b>
|
|
// : boost::true_type {};
|
|
// Advertise somehow that the sign_of_determinant* are exact?
|
|
|
|
typedef cpp0x::array<NT1,2> Vector;
|
|
struct Construct_vector {
|
|
struct Dimension {
|
|
Vector operator()(unsigned d) const {
|
|
CGAL_assertion(d==2);
|
|
return Vector();
|
|
}
|
|
};
|
|
|
|
// TODO (for all constructors): check that input fits in NT1...
|
|
struct Iterator {
|
|
template<typename Iter>
|
|
Vector operator()(unsigned d,Iter const& f,Iter const& e) const {
|
|
CGAL_assertion(d==2);
|
|
NT1 x0 = *f;
|
|
NT1 x1 = *++f;
|
|
CGAL_assertion(++f==e);
|
|
Vector a = { x0, x1 };
|
|
return a;
|
|
}
|
|
};
|
|
|
|
struct Iterator_and_last {
|
|
template<typename Iter,typename T>
|
|
Vector operator()(unsigned d,Iter const& f,Iter const& e,double t) const {
|
|
CGAL_assertion(d==2);
|
|
Vector a = { static_cast<NT1>(*f), t };
|
|
CGAL_assertion(++f==e);
|
|
return a;
|
|
}
|
|
};
|
|
|
|
struct Values {
|
|
Vector operator()(NT1 a,NT1 b) const {
|
|
Vector r = { a, b };
|
|
return r;
|
|
}
|
|
};
|
|
|
|
/*
|
|
// Maybe safer not to provide it
|
|
struct Values_divide {
|
|
Vector operator()(double h,double a,double b) const {
|
|
Vector r = { a/h, b/h };
|
|
return r;
|
|
}
|
|
};
|
|
*/
|
|
};
|
|
|
|
// Since we lie about NT, be consistent about it
|
|
typedef transforming_iterator<NT_converter<NT1,NT>,NT1 const*> Vector_const_iterator;
|
|
static inline Vector_const_iterator vector_begin(Vector const&a){
|
|
return Vector_const_iterator(a.begin());
|
|
}
|
|
static inline Vector_const_iterator vector_end(Vector const&a){
|
|
return Vector_const_iterator(a.end());
|
|
}
|
|
static inline unsigned size_of_vector(Vector){
|
|
return 2;
|
|
}
|
|
|
|
// for unsigned NT1, check what changes to do.
|
|
// return NT instead?
|
|
static NT2 determinant_of_vectors(Vector a, Vector b) {
|
|
return CGAL::determinant_of_vectors<NT2>(a,b);
|
|
}
|
|
static CGAL::Sign sign_of_determinant_of_vectors(Vector a, Vector b) {
|
|
return CGAL::sign_of_determinant_of_vectors<NT2>(a,b);
|
|
}
|
|
|
|
#if 0
|
|
// WARNING: FIXME: Completely broken as is
|
|
// TODO: put an assertion at construction that abs(coord)<INTMAX/sqrt(2) or something
|
|
static NT determinant_of_points(Vector a, Vector b, Vector c) {
|
|
NT2 a0=a[0]; NT2 a1=a[1];
|
|
NT2 x0=b[0]-a0; NT2 x1=b[1]-a1;
|
|
NT2 y0=c[0]-a0; NT2 y1=c[1]-a1;
|
|
return CGAL::determinant<NT>(x0,x1,y0,y1);
|
|
}
|
|
static CGAL::Sign sign_of_determinant_of_points(Vector a, Vector b, Vector c) {
|
|
NT2 a0=a[0]; NT2 a1=a[1];
|
|
NT2 x0=b[0]-a0; NT2 x1=b[1]-a1;
|
|
NT2 y0=c[0]-a0; NT2 y1=c[1]-a1;
|
|
return CGAL::compare(x0*y1,x1*y0);
|
|
}
|
|
#endif
|
|
};
|
|
|
|
}
|
|
#endif
|