← Back to branch summary

~ubuntu-branches/ubuntu/maverick/freecad/maverick

« back to all changes in this revision

Viewing changes to src/Mod/Mesh/App/WildMagic4/Wm4GVector.inl

  • Committer: Bazaar Package Importer
  • Author(s): Teemu Ikonen
  • Date: 2009-07-16 18:37:41 UTC
  • Revision ID: james.westby@ubuntu.com-20090716183741-oww9kcxqrk991i1n
Tags: upstream-0.8.2237
Import upstream version 0.8.2237

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Mod/Mesh/App/WildMagic4/Wm4GVector.inl
 
1
// Wild Magic Source Code
 
2
// David Eberly
 
3
// http://www.geometrictools.com
 
4
// Copyright (c) 1998-2007
 
5
//
 
6
// This library is free software; you can redistribute it and/or modify it
 
7
// under the terms of the GNU Lesser General Public License as published by
 
8
// the Free Software Foundation; either version 2.1 of the License, or (at
 
9
// your option) any later version.  The license is available for reading at
 
10
// either of the locations:
 
11
//     http://www.gnu.org/copyleft/lgpl.html
 
12
//     http://www.geometrictools.com/License/WildMagicLicense.pdf
 
13
// The license applies to versions 0 through 4 of Wild Magic.
 
14
//
 
15
// Version: 4.0.0 (2006/06/28)
 
16
 
 
17
//----------------------------------------------------------------------------
 
18
template <class Real>
 
19
GVector<Real>::GVector (int iSize)
 
20
{
 
21
    if (iSize > 0)
 
22
    {
 
23
        m_iSize = iSize;
 
24
        m_afTuple = WM4_NEW Real[m_iSize];
 
25
        memset(m_afTuple,0,m_iSize*sizeof(Real));
 
26
    }
 
27
    else
 
28
    {
 
29
        m_iSize = 0;
 
30
        m_afTuple = 0;
 
31
    }
 
32
}
 
33
//----------------------------------------------------------------------------
 
34
template <class Real>
 
35
GVector<Real>::GVector (int iSize, const Real* afTuple)
 
36
{
 
37
    if (iSize > 0)
 
38
    {
 
39
        m_iSize = iSize;
 
40
        m_afTuple = WM4_NEW Real[m_iSize];
 
41
        size_t uiSize = m_iSize*sizeof(Real);
 
42
        System::Memcpy(m_afTuple,uiSize,afTuple,uiSize);
 
43
    }
 
44
    else
 
45
    {
 
46
        m_iSize = 0;
 
47
        m_afTuple = 0;
 
48
    }
 
49
}
 
50
//----------------------------------------------------------------------------
 
51
template <class Real>
 
52
GVector<Real>::GVector (const GVector& rkV)
 
53
{
 
54
    m_iSize = rkV.m_iSize;
 
55
    if (m_iSize > 0)
 
56
    {
 
57
        m_afTuple = WM4_NEW Real[m_iSize];
 
58
        size_t uiSize = m_iSize*sizeof(Real);
 
59
        System::Memcpy(m_afTuple,uiSize,rkV.m_afTuple,uiSize);
 
60
    }
 
61
    else
 
62
    {
 
63
        m_afTuple = 0;
 
64
    }
 
65
}
 
66
//----------------------------------------------------------------------------
 
67
template <class Real>
 
68
GVector<Real>::~GVector ()
 
69
{
 
70
    WM4_DELETE[] m_afTuple;
 
71
}
 
72
//----------------------------------------------------------------------------
 
73
template <class Real>
 
74
void GVector<Real>::SetSize (int iSize)
 
75
{
 
76
    WM4_DELETE[] m_afTuple;
 
77
    if (iSize > 0)
 
78
    {
 
79
        m_iSize = iSize;
 
80
        m_afTuple = WM4_NEW Real[m_iSize];
 
81
        memset(m_afTuple,0,m_iSize*sizeof(Real));
 
82
    }
 
83
    else
 
84
    {
 
85
        m_iSize = 0;
 
86
        m_afTuple = 0;
 
87
    }
 
88
}
 
89
//----------------------------------------------------------------------------
 
90
template <class Real>
 
91
int GVector<Real>::GetSize () const
 
92
{
 
93
    return m_iSize;
 
94
}
 
95
//----------------------------------------------------------------------------
 
96
template <class Real>
 
97
GVector<Real>::operator const Real* () const
 
98
{
 
99
    return m_afTuple;
 
100
}
 
101
//----------------------------------------------------------------------------
 
102
template <class Real>
 
103
GVector<Real>::operator Real* ()
 
104
{
 
105
    return m_afTuple;
 
106
}
 
107
//----------------------------------------------------------------------------
 
108
template <class Real>
 
109
Real GVector<Real>::operator[] (int i) const
 
110
{
 
111
    assert(0 <= i && i < m_iSize);
 
112
    return m_afTuple[i];
 
113
}
 
114
//----------------------------------------------------------------------------
 
115
template <class Real>
 
116
Real& GVector<Real>::operator[] (int i)
 
117
{
 
118
    assert(0 <= i && i < m_iSize);
 
119
    return m_afTuple[i];
 
120
}
 
121
//----------------------------------------------------------------------------
 
122
template <class Real>
 
123
GVector<Real>& GVector<Real>::operator= (const GVector& rkV)
 
124
{
 
125
    if (rkV.m_iSize > 0)
 
126
    {
 
127
        if (m_iSize != rkV.m_iSize)
 
128
        {
 
129
            WM4_DELETE[] m_afTuple;
 
130
            m_iSize = rkV.m_iSize;
 
131
            m_afTuple = WM4_NEW Real[m_iSize];
 
132
        }
 
133
        size_t uiSize = m_iSize*sizeof(Real);
 
134
        System::Memcpy(m_afTuple,uiSize,rkV.m_afTuple,uiSize);
 
135
    }
 
136
    else
 
137
    {
 
138
        WM4_DELETE[] m_afTuple;
 
139
        m_iSize = 0;
 
140
        m_afTuple = 0;
 
141
    }
 
142
    return *this;
 
143
}
 
144
//----------------------------------------------------------------------------
 
145
template <class Real>
 
146
int GVector<Real>::CompareArrays (const GVector& rkV) const
 
147
{
 
148
    return memcmp(m_afTuple,rkV.m_afTuple,m_iSize*sizeof(Real));
 
149
}
 
150
//----------------------------------------------------------------------------
 
151
template <class Real>
 
152
bool GVector<Real>::operator== (const GVector& rkV) const
 
153
{
 
154
    return CompareArrays(rkV) == 0;
 
155
}
 
156
//----------------------------------------------------------------------------
 
157
template <class Real>
 
158
bool GVector<Real>::operator!= (const GVector& rkV) const
 
159
{
 
160
    return CompareArrays(rkV) != 0;
 
161
}
 
162
//----------------------------------------------------------------------------
 
163
template <class Real>
 
164
bool GVector<Real>::operator< (const GVector& rkV) const
 
165
{
 
166
    return CompareArrays(rkV) < 0;
 
167
}
 
168
//----------------------------------------------------------------------------
 
169
template <class Real>
 
170
bool GVector<Real>::operator<= (const GVector& rkV) const
 
171
{
 
172
    return CompareArrays(rkV) <= 0;
 
173
}
 
174
//----------------------------------------------------------------------------
 
175
template <class Real>
 
176
bool GVector<Real>::operator> (const GVector& rkV) const
 
177
{
 
178
    return CompareArrays(rkV) > 0;
 
179
}
 
180
//----------------------------------------------------------------------------
 
181
template <class Real>
 
182
bool GVector<Real>::operator>= (const GVector& rkV) const
 
183
{
 
184
    return CompareArrays(rkV) >= 0;
 
185
}
 
186
//----------------------------------------------------------------------------
 
187
template <class Real>
 
188
GVector<Real> GVector<Real>::operator+ (const GVector& rkV) const
 
189
{
 
190
    GVector<Real> kSum(m_iSize);
 
191
    for (int i = 0; i < m_iSize; i++)
 
192
    {
 
193
        kSum.m_afTuple[i] = m_afTuple[i] + rkV.m_afTuple[i];
 
194
    }
 
195
    return kSum;
 
196
}
 
197
//----------------------------------------------------------------------------
 
198
template <class Real>
 
199
GVector<Real> GVector<Real>::operator- (const GVector& rkV) const
 
200
{
 
201
    GVector<Real> kDiff(m_iSize);
 
202
    for (int i = 0; i < m_iSize; i++)
 
203
    {
 
204
        kDiff.m_afTuple[i] = m_afTuple[i] - rkV.m_afTuple[i];
 
205
    }
 
206
    return kDiff;
 
207
}
 
208
//----------------------------------------------------------------------------
 
209
template <class Real>
 
210
GVector<Real> GVector<Real>::operator* (Real fScalar) const
 
211
{
 
212
    GVector<Real> kProd(m_iSize);
 
213
    for (int i = 0; i < m_iSize; i++)
 
214
    {
 
215
        kProd.m_afTuple[i] = fScalar*m_afTuple[i];
 
216
    }
 
217
    return kProd;
 
218
}
 
219
//----------------------------------------------------------------------------
 
220
template <class Real>
 
221
GVector<Real> GVector<Real>::operator/ (Real fScalar) const
 
222
{
 
223
    GVector<Real> kQuot(m_iSize);
 
224
    int i;
 
225
 
 
226
    if (fScalar != (Real)0.0)
 
227
    {
 
228
        Real fInvScalar = ((Real)1.0)/fScalar;
 
229
        for (i = 0; i < m_iSize; i++)
 
230
        {
 
231
            kQuot.m_afTuple[i] = fInvScalar*m_afTuple[i];
 
232
        }
 
233
    }
 
234
    else
 
235
    {
 
236
        for (i = 0; i < m_iSize; i++)
 
237
        {
 
238
            kQuot.m_afTuple[i] = Math<Real>::MAX_REAL;
 
239
        }
 
240
    }
 
241
 
 
242
    return kQuot;
 
243
}
 
244
//----------------------------------------------------------------------------
 
245
template <class Real>
 
246
GVector<Real> GVector<Real>::operator- () const
 
247
{
 
248
    GVector<Real> kNeg(m_iSize);
 
249
    for (int i = 0; i < m_iSize; i++)
 
250
    {
 
251
        kNeg.m_afTuple[i] = -m_afTuple[i];
 
252
    }
 
253
    return kNeg;
 
254
}
 
255
//----------------------------------------------------------------------------
 
256
template <class Real>
 
257
GVector<Real> operator* (Real fScalar, const GVector<Real>& rkV)
 
258
{
 
259
    GVector<Real> kProd(rkV.GetSize());
 
260
    for (int i = 0; i < rkV.GetSize(); i++)
 
261
    {
 
262
        kProd[i] = fScalar*rkV[i];
 
263
    }
 
264
    return kProd;
 
265
}
 
266
//----------------------------------------------------------------------------
 
267
template <class Real>
 
268
GVector<Real>& GVector<Real>::operator+= (const GVector& rkV)
 
269
{
 
270
    for (int i = 0; i < m_iSize; i++)
 
271
    {
 
272
        m_afTuple[i] += rkV.m_afTuple[i];
 
273
    }
 
274
    return *this;
 
275
}
 
276
//----------------------------------------------------------------------------
 
277
template <class Real>
 
278
GVector<Real>& GVector<Real>::operator-= (const GVector& rkV)
 
279
{
 
280
    for (int i = 0; i < m_iSize; i++)
 
281
    {
 
282
        m_afTuple[i] -= rkV.m_afTuple[i];
 
283
    }
 
284
    return *this;
 
285
}
 
286
//----------------------------------------------------------------------------
 
287
template <class Real>
 
288
GVector<Real>& GVector<Real>::operator*= (Real fScalar)
 
289
{
 
290
    for (int i = 0; i < m_iSize; i++)
 
291
    {
 
292
        m_afTuple[i] *= fScalar;
 
293
    }
 
294
    return *this;
 
295
}
 
296
//----------------------------------------------------------------------------
 
297
template <class Real>
 
298
GVector<Real>& GVector<Real>::operator/= (Real fScalar)
 
299
{
 
300
    int i;
 
301
 
 
302
    if (fScalar != (Real)0.0)
 
303
    {
 
304
        Real fInvScalar = ((Real)1.0)/fScalar;
 
305
        for (i = 0; i < m_iSize; i++)
 
306
        {
 
307
            m_afTuple[i] *= fInvScalar;
 
308
        }
 
309
    }
 
310
    else
 
311
    {
 
312
        for (i = 0; i < m_iSize; i++)
 
313
        {
 
314
            m_afTuple[i] = Math<Real>::MAX_REAL;
 
315
        }
 
316
    }
 
317
 
 
318
    return *this;
 
319
}
 
320
//----------------------------------------------------------------------------
 
321
template <class Real>
 
322
Real GVector<Real>::Length () const
 
323
{
 
324
    Real fSqrLen = (Real)0.0;
 
325
    for (int i = 0; i < m_iSize; i++)
 
326
    {
 
327
        fSqrLen += m_afTuple[i]*m_afTuple[i];
 
328
    }
 
329
    return Math<Real>::Sqrt(fSqrLen);
 
330
}
 
331
//----------------------------------------------------------------------------
 
332
template <class Real>
 
333
Real GVector<Real>::SquaredLength () const
 
334
{
 
335
    Real fSqrLen = (Real)0.0;
 
336
    for (int i = 0; i < m_iSize; i++)
 
337
    {
 
338
        fSqrLen += m_afTuple[i]*m_afTuple[i];
 
339
    }
 
340
    return fSqrLen;
 
341
}
 
342
//----------------------------------------------------------------------------
 
343
template <class Real>
 
344
Real GVector<Real>::Dot (const GVector& rkV) const
 
345
{
 
346
    Real fDot = (Real)0.0;
 
347
    for (int i = 0; i < m_iSize; i++)
 
348
    {
 
349
        fDot += m_afTuple[i]*rkV.m_afTuple[i];
 
350
    }
 
351
    return fDot;
 
352
}
 
353
//----------------------------------------------------------------------------
 
354
template <class Real>
 
355
Real GVector<Real>::Normalize ()
 
356
{
 
357
    Real fLength = Length();
 
358
    int i;
 
359
 
 
360
    if (fLength > Math<Real>::ZERO_TOLERANCE)
 
361
    {
 
362
        Real fInvLength = ((Real)1.0)/fLength;
 
363
        for (i = 0; i < m_iSize; i++)
 
364
        {
 
365
            m_afTuple[i] *= fInvLength;
 
366
        }
 
367
    }
 
368
    else
 
369
    {
 
370
        fLength = (Real)0.0;
 
371
        for (i = 0; i < m_iSize; i++)
 
372
        {
 
373
            m_afTuple[i] = (Real)0.0;
 
374
        }
 
375
    }
 
376
 
 
377
    return fLength;
 
378
}
 
379
//----------------------------------------------------------------------------