← Back to branch summary

~jfpacker/pyeigen/bugfixes-0.1

« back to all changes in this revision

Viewing changes to source/vector/rowvector2f.cpp

  • Committer: Jussi Lepistö
  • Date: 2010-03-22 23:20:03 UTC
  • Revision ID: jussi.lepisto@iki.fi-20100322232003-tzqb9tng6sbq2kdf
- transpose setter for vectors
- Code review & cleanup for all classes

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/vector/rowvector2f.cpp
1
1
// Copyright 2010 Jussi Lepisto
2
2
 
3
 
#include "rowvector2f.h"
 
3
#include "RowVector2f.h"
4
4
 
5
5
#include <Eigen/Array>
6
6
#include <Eigen/Geometry>
7
7
 
8
 
#include "matrix/matrix2f.h"
9
8
#include "util/macros.h"
10
 
#include "vector/vector2f.h"
 
9
#include "vector/Vector2f.h"
11
10
 
12
11
 
13
12
// Structures
25
24
         "This vector divided by its norm.", NULL},
26
25
        {"transpose",   (getter)RowVector2f_get_transpose,      NULL,
27
26
         "Transpose of this vector.", NULL},
 
27
        {"transpose",
 
28
         (getter)RowVector2f_get_transpose, (setter)RowVector2f_set_transpose,
 
29
         "Transpose of this vector.", NULL},
28
30
 
29
31
        {NULL}
30
32
};
134
136
        Py_TPFLAGS_DEFAULT |                    // tp_flags
135
137
        Py_TPFLAGS_BASETYPE |
136
138
        Py_TPFLAGS_CHECKTYPES,
137
 
        "2-dimensional row vector with float elements", // tp_doc
 
139
        "2-dimensional vector with float elements",     // tp_doc
138
140
        0,                                                              // tp_traverse
139
141
        0,                                                              // tp_clear
140
142
        RowVector2f_richcompare,                // tp_richcompare
193
195
int RowVector2f_set_x(RowVector2f* self, PyObject* value, void* closure)
194
196
{
195
197
        self->vector.x() = (float)PyFloat_AsDouble(value);
196
 
        if(PyErr_Occurred() != NULL)
 
198
        if(PyErr_Occurred())
197
199
                return -1;
198
200
 
199
201
        return 0;
207
209
int RowVector2f_set_y(RowVector2f* self, PyObject* value, void* closure)
208
210
{
209
211
        self->vector.y() = (float)PyFloat_AsDouble(value);
210
 
        if(PyErr_Occurred() != NULL)
 
212
        if(PyErr_Occurred())
211
213
                return -1;
212
214
 
213
215
        return 0;
241
243
        return (PyObject*)result;
242
244
}
243
245
 
 
246
int RowVector2f_set_transpose(RowVector2f* self, PyObject* value,
 
247
        void* closure)
 
248
{
 
249
        if(!Vector2f_Check(value))
 
250
        {
 
251
                PyErr_SetString(PyExc_TypeError, "transpose must be a Vector2f");
 
252
                return -1;
 
253
        }
 
254
 
 
255
        Vector2f* v = (Vector2f*)value;
 
256
        self->vector.transpose() = v->vector;
 
257
        return 0;
 
258
}
 
259
 
244
260
// Methods
245
261
PyObject* RowVector2f_zero(PyTypeObject* cls, PyObject* noargs)
246
262
{
286
302
{
287
303
        RowVector2f* result = PyObject_New(RowVector2f, cls);
288
304
        if(result != NULL)
289
 
                result->vector << 1.f, 0.f;
 
305
                result->vector << 1.0f, 0.0f;
290
306
 
291
307
        return (PyObject*)result;
292
308
}
295
311
{
296
312
        RowVector2f* result = PyObject_New(RowVector2f, cls);
297
313
        if(result != NULL)
298
 
                result->vector << 0.f, 1.f;
 
314
                result->vector << 0.0f, 1.0f;
299
315
 
300
316
        return (PyObject*)result;
301
317
}
388
404
 
389
405
PyObject* RowVector2f_multiply(PyObject* o1, PyObject* o2)
390
406
{
391
 
        // Matrix multiply
392
 
        if(RowVector2f_Check(o1) && Matrix2f_Check(o2))
393
 
        {
394
 
                RowVector2f* v = (RowVector2f*)o1;
395
 
                Matrix2f* m = (Matrix2f*)o2;
396
 
 
397
 
                RowVector2f* result = PyObject_New(RowVector2f, &RowVector2fType);
398
 
                if(result != NULL)
399
 
                        result->vector = v->vector * m->matrix;
400
 
 
401
 
                return (PyObject*)result;
402
 
        }
403
 
        // Scalar multiply
404
 
        else if(RowVector2f_Check(o1) && PyNumber_Check(o2))
 
407
        if(RowVector2f_Check(o1) && PyNumber_Check(o2))
405
408
        {
406
409
                RowVector2f* v = (RowVector2f*)o1;
407
410
                float scalar = (float)PyFloat_AsDouble(o2);
408
 
                if(PyErr_Occurred() != NULL)
 
411
                if(PyErr_Occurred())
409
412
                        return NULL;
410
413
 
411
414
                RowVector2f* result = PyObject_New(RowVector2f, &RowVector2fType);
412
415
                if(result != NULL)
413
416
                        result->vector = v->vector * scalar;
414
 
 
415
417
                return (PyObject*)result;
416
418
        }
417
419
        else if(PyNumber_Check(o1) && RowVector2f_Check(o2))
418
420
        {
419
421
                float scalar = (float)PyFloat_AsDouble(o1);
420
422
                RowVector2f* v = (RowVector2f*)o2;
421
 
                if(PyErr_Occurred() != NULL)
 
423
                if(PyErr_Occurred())
422
424
                        return NULL;
423
425
 
424
426
                RowVector2f* result = PyObject_New(RowVector2f, &RowVector2fType);
425
427
                if(result != NULL)
426
428
                        result->vector = v->vector * scalar;
427
 
 
428
429
                return (PyObject*)result;
429
430
        }
430
431
 
438
439
 
439
440
        RowVector2f* v = (RowVector2f*)o1;
440
441
        float scalar = (float)PyFloat_AsDouble(o2);
441
 
        if(PyErr_Occurred() != NULL)
 
442
        if(PyErr_Occurred())
442
443
                return NULL;
443
444
 
444
445
        RowVector2f* result = PyObject_New(RowVector2f, &RowVector2fType);
450
451
 
451
452
PyObject* RowVector2f_negative(PyObject* o)
452
453
{
453
 
        if(!RowVector2f_Check(o))
454
 
                pyeigen_RETURN_NOTIMPLEMENTED;
455
 
 
456
454
        RowVector2f* v = (RowVector2f*)o;
457
455
        RowVector2f* result = PyObject_New(RowVector2f, &RowVector2fType);
458
456
        if(result != NULL)
463
461
 
464
462
PyObject* RowVector2f_inplace_add(PyObject* o1, PyObject* o2)
465
463
{
466
 
        if(!RowVector2f_Check(o1) || !PyNumber_Check(o2))
 
464
        if(!RowVector2f_Check(o1) || !RowVector2f_Check(o2))
467
465
                pyeigen_RETURN_NOTIMPLEMENTED;
468
466
 
469
467
        RowVector2f* v1 = (RowVector2f*)o1;
470
468
        RowVector2f* v2 = (RowVector2f*)o2;
 
469
 
471
470
        v1->vector += v2->vector;
472
471
 
473
 
        return o1;
 
472
        Py_INCREF(v1);
 
473
        return (PyObject*)v1;
474
474
}
475
475
 
476
476
PyObject* RowVector2f_inplace_subtract(PyObject* o1, PyObject* o2)
477
477
{
478
 
        if(!RowVector2f_Check(o1) || !PyNumber_Check(o2))
 
478
        if(!RowVector2f_Check(o1) || !RowVector2f_Check(o2))
479
479
                pyeigen_RETURN_NOTIMPLEMENTED;
480
480
 
481
481
        RowVector2f* v1 = (RowVector2f*)o1;
482
482
        RowVector2f* v2 = (RowVector2f*)o2;
 
483
 
483
484
        v1->vector -= v2->vector;
484
485
 
485
 
        return o1;
 
486
        Py_INCREF(v1);
 
487
        return (PyObject*)v1;
486
488
}
487
489
 
488
490
PyObject* RowVector2f_inplace_multiply(PyObject* o1, PyObject* o2)
489
491
{
490
 
        RowVector2f* v = (RowVector2f*)o1;
491
 
 
492
 
        // Matrix multiply
493
 
        if(Matrix2f_Check(o2))
494
 
        {
495
 
                Matrix2f* m = (Matrix2f*)o2;
496
 
                v->vector *= m->matrix;
497
 
        }
498
 
        // Scalar multiply
499
 
        else if(RowVector2f_Check(o1) && PyNumber_Check(o2))
500
 
        {
 
492
        if(RowVector2f_Check(o1) && PyNumber_Check(o2))
 
493
        {
 
494
                RowVector2f* v = (RowVector2f*)o1;
501
495
                float scalar = (float)PyFloat_AsDouble(o2);
502
 
                if(PyErr_Occurred() != NULL)
 
496
                if(PyErr_Occurred())
503
497
                        return NULL;
504
498
 
505
499
                v->vector *= scalar;
 
500
 
 
501
                Py_INCREF(v);
 
502
                return (PyObject*)v;
506
503
        }
507
504
        else if(PyNumber_Check(o1) && RowVector2f_Check(o2))
508
505
        {
509
506
                float scalar = (float)PyFloat_AsDouble(o1);
510
 
                if(PyErr_Occurred() != NULL)
 
507
                RowVector2f* v = (RowVector2f*)o2;
 
508
                if(PyErr_Occurred())
511
509
                        return NULL;
512
510
 
513
511
                v->vector *= scalar;
 
512
 
 
513
                Py_INCREF(v);
 
514
                return (PyObject*)v;
514
515
        }
515
 
        else
516
 
                pyeigen_RETURN_NOTIMPLEMENTED;
517
516
 
518
 
        return (PyObject*)v;
 
517
        pyeigen_RETURN_NOTIMPLEMENTED;
519
518
}
520
519
 
521
520
PyObject* RowVector2f_inplace_divide(PyObject* o1, PyObject* o2)
522
521
{
523
 
        if(!PyNumber_Check(o2))
 
522
        if(!RowVector2f_Check(o1) || !PyNumber_Check(o2))
524
523
                pyeigen_RETURN_NOTIMPLEMENTED;
525
524
 
526
525
        RowVector2f* v = (RowVector2f*)o1;
527
526
        float scalar = (float)PyFloat_AsDouble(o2);
528
 
        if(PyErr_Occurred() != NULL)
 
527
        if(PyErr_Occurred())
529
528
                return NULL;
530
529
 
531
530
        v->vector /= scalar;
532
531
 
 
532
        Py_INCREF(v);
533
533
        return (PyObject*)v;
534
534
}
 
535
 
535
536
// Sequence methods
536
537
Py_ssize_t RowVector2f_length(RowVector2f* self)
537
538
{
549
550
        return PyFloat_FromDouble(self->vector[(int)index]);
550
551
}
551
552
 
552
 
PyObject* RowVector2f_slice(RowVector2f* self, Py_ssize_t index1,
553
 
        Py_ssize_t index2)
 
553
PyObject* RowVector2f_slice(RowVector2f* self, Py_ssize_t index1, Py_ssize_t index2)
554
554
{
555
555
        if(index1 > 2)
556
556
                index1 = 2;
587
587
        }
588
588
 
589
589
        self->vector[(int)index] = (float)PyFloat_AsDouble(value);
590
 
        if(PyErr_Occurred() != NULL)
 
590
        if(PyErr_Occurred())
591
591
                return -1;
592
592
 
593
593
        return 0;
594
594
}
595
595
 
596
 
int RowVector2f_ass_slice(RowVector2f* self, Py_ssize_t index1,
597
 
        Py_ssize_t index2, PyObject* value)
 
596
int RowVector2f_ass_slice(RowVector2f* self, Py_ssize_t index1, Py_ssize_t index2,
 
597
        PyObject* value)
598
598
{
599
599
        if(index1 > 2)
600
600
                index1 = 2;
615
615
        {
616
616
                self->vector[(int)index] =
617
617
                        (float)PyFloat_AsDouble(PySequence_GetItem(value, index));
618
 
                if(PyErr_Occurred() != NULL)
 
618
                if(PyErr_Occurred())
619
619
                        return -1;
620
620
        }
621
621