1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// PR tree-optimization/56381
// { dg-do compile }
// { dg-options "-std=c++11 -O2 -w" }
template <class>
class intrusive_ptr {};
class BasicReferenceCounted
{
};
template <class T>
class ReferenceCountingPointer : intrusive_ptr <T>
{
};
typedef BasicReferenceCounted ReferenceCountedInConditions;
class PointTag;
template <typename T, typename>
struct PreciseFloatType
{
typedef T Type;
};
template <typename T, int N>
struct ExtVecTraits
{
typedef T __attribute__ ((vector_size (N * sizeof (T)))) type;
};
template <typename T, int N>
using ExtVec = typename ExtVecTraits <T, N>::type;
template <typename T> using Vec4 = ExtVec <T, 4>;
template <typename Vec>
Vec cross3 (Vec x, Vec y)
{
Vec x1200 = (Vec) { x[2], x[0] };
Vec y2010 { y[2], y[0], y[1], y[0] };
Vec x2010 = (Vec) { x[2], x[0], x[1], x[0] };
Vec y1200 = (Vec) { y[1], y[0] };
return x1200 * y2010 - x2010 * y1200;
}
template <typename T>
struct Rot3
{
typedef Vec4 <T> Vec;
Vec axis[3];
};
class Basic2DVector
{
};
template <typename T>
struct Basic3DVector
{
typedef Vec4 <T> MathVector;
Basic3DVector (MathVector iv) : v { (iv[0]), (iv[1]), (iv[2]), (iv[3]) } {}
T mag2 () {}
Basic3DVector unit ()
{
T my_mag = mag2 ();
return (my_mag) ? (*this) * (T () / (my_mag)) : *this;
}
Basic3DVector
cross (Basic3DVector lh) { return cross3 (v, lh.v); }
Vec4 <T> v;
};
template <class T>
Basic3DVector <T> operator * (Basic3DVector <T>, T);
template <class T, class, class>
struct PV3DBase
{
typedef Basic3DVector <T> BasicVectorType;
template <class U>
PV3DBase (Basic3DVector <U> v) : theVector (v) {}
BasicVectorType basicVector () { return theVector; }
T x ();
T y ();
BasicVectorType theVector;
};
class VectorTag;
template <class T, class FrameTag>
struct Vector3DBase:public PV3DBase <T, VectorTag, FrameTag>
{
typedef PV3DBase <T, VectorTag, FrameTag> BaseClass;
template <class U>
Vector3DBase (Basic3DVector <U> v) : BaseClass (v) {}
Vector3DBase unit () { return (this->basicVector ().unit ()); }
template <class U>
Vector3DBase <typename PreciseFloatType <T, U>::Type, FrameTag> cross (Vector3DBase <U, FrameTag> v)
{
return (this->theVector.cross (v.basicVector ()));
}
};
template <class T, class FrameTag>
class Point3DBase : public PV3DBase <T, PointTag, FrameTag>
{
};
template <typename T, typename U, class Frame>
Vector3DBase <typename PreciseFloatType <T, U>::Type, Frame> operator - (Point3DBase <T, Frame>, Point3DBase <U, Frame>);
class GlobalTag;
template <class T>
struct TkRotation
{
typedef Vector3DBase <T, GlobalTag> GlobalVector;
TkRotation (GlobalVector aX, GlobalVector aY)
{
GlobalVector uX = aX.unit ();
GlobalVector uY = aY.unit ();
GlobalVector uZ (uX.cross (uY));
rot.axis[2] = uZ.basicVector ().v;
}
Basic3DVector <T> z ();
Rot3 <T> rot;
};
template <class T>
struct GloballyPositioned
{
typedef Point3DBase <T, GlobalTag> PositionType;
typedef TkRotation <T> RotationType;
typedef Point3DBase <T, GlobalTag> GlobalPoint;
typedef Vector3DBase <T, GlobalTag> GlobalVector;
T iniPhi () { return 999.9978; }
GloballyPositioned (PositionType pos, RotationType rot) : thePos (pos), theRot (rot) { resetCache (); }
PositionType position () const;
RotationType rotation () const;
PositionType thePos;
RotationType theRot;
void resetCache ()
{
if ((thePos.x () == 0.) && (thePos.y () == 0.))
thePhi = 0.;
else
thePhi = iniPhi ();
}
T thePhi;
};
class Plane;
using TangentPlane = Plane;
struct Surface : public GloballyPositioned <float>, ReferenceCountedInConditions
{
typedef GloballyPositioned <float> Base;
Surface (PositionType pos, RotationType rot):
Base (pos, rot) {}
};
struct Plane : Surface
{
template <typename ... Args>
Plane (Args ... args):
Surface ((args) ...) {}
};
class Cylinder : Surface
{
void tangentPlane (const GlobalPoint &) const;
};
void
Cylinder::tangentPlane (const GlobalPoint & aPoint) const
{
GlobalVector yPlane (rotation ().z ());
GlobalVector xPlane (yPlane.cross (aPoint - position ()));
new TangentPlane (aPoint, RotationType (xPlane, yPlane));
}
|
