---

vector.cc

Go to the documentation of this file.

#include "vector.hh"
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

namespace anoid {
    namespace simple {

        using namespace std;

        void Vector::init(const char *s) {
            char *c = strdup(s);
            if (sscanf(c, "(%lf,%lf,%lf)", &x, &y, &z) != 3)
                x = y = z = 0.0;
            free(c);
        }

        Vector::Vector(double getx, double gety, double getz): Point(getx, gety, getz) {
        }

        Vector::Vector(string &s): Point() {
            init(s.c_str());
        }

        Vector::Vector(char *s): Point() {
            init(s);
        }

        double Vector::getNorm() const {
            return sqrt((double)((*this)*(*this)));
        }

        void Vector::setNorm(double newnorm) {
            double temp = getNorm();
            x = (double)((x*newnorm)/temp);
            y = (double)((y*newnorm)/temp);
            z = (double)((z*newnorm)/temp);
        }

        void Vector::scale(const Vector& v) {
            x *= v.x;
            y *= v.y;
            z *= v.z;
        }

        Vector operator+(const Vector& a, const Vector& b) {
            return Vector(a.x+b.x,a.y+b.y,a.z+b.z);
        }

        Vector operator+=(Vector &a, const Vector& b) {
            a.x += b.x;
            a.y += b.y;
            a.z += b.z;
            return a;
        }

        Vector Vector::operator=(const Vector& a) {
            x = a.x;
            y = a.y;
            z = a.z;
            return *this;
        }

        Vector operator-(const Vector& a, const Vector& b) {
            return a+((-1)*b);
        }

        Vector operator*(const double c, const Vector& a) {
            return Vector(c*a.x,c*a.y,c*a.z);
        }

        Vector operator*(const Vector& a, const double c) {
            return c*a;
        }

        double operator*(const Vector& a, const Vector& b) {
            return a.x*b.x+a.y*b.y+a.z*b.z;
        }

        Vector operator%(const Vector& a, const Vector& b) {
            return Vector(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);
        }

        ostream& operator<<(ostream& s, const Vector& a) {
            s << '(' << a.x << ',' << a.y << ',' << a.z << ')';
            return s;
        }

        Vector operator*(const double *d, const Vector &a) {
            return Vector(d[0] * a.x + d[4] * a.y + d[8] * a.z,
                    d[1] * a.x + d[5] * a.y + d[9] * a.z,
                    d[2] * a.x + d[6] * a.y + d[10] * a.z);
        }

        Vector operator*(const Vector &a, const double *d) {
            return Vector((d[0] + d[1] + d[2]) * a.x,
                    (d[4] + d[5] + d[6]) * a.y,
                    (d[8] + d[9] + d[10]) * a.z);
        }

    };
};

double *matMult(double *A, const double* B) {
    double tmp[16];
    tmp[0] = A[0] * B[0] + A[4] * B[1] + A[8] * B[2];
    tmp[4] = A[0] * B[4] + A[4] * B[5] + A[8] * B[6];
    tmp[8] = A[0] * B[8] + A[4] * B[9] + A[8] * B[10];

    tmp[1] = A[1] * B[0] + A[5] * B[1] + A[9] * B[2];
    tmp[5] = A[1] * B[4] + A[5] * B[5] + A[9] * B[6];
    tmp[9] = A[1] * B[8] + A[5] * B[9] + A[9] * B[10];

    tmp[2] = A[2] * B[0] + A[6] * B[1] + A[10] * B[2];
    tmp[6] = A[2] * B[4] + A[6] * B[5] + A[10] * B[6];
    tmp[10] = A[2] * B[8] + A[6] * B[9] + A[10] * B[10];

    A[0] = tmp[0];
    A[1] = tmp[1];
    A[2] = tmp[2];
    A[4] = tmp[4];
    A[5] = tmp[5];
    A[6] = tmp[6];
    A[8] = tmp[8];
    A[9] = tmp[9];
    A[10] = tmp[10];

    return A;
}

double *matAdd(double *A, const double *B) {
    A[0] += B[0];
    A[1] += B[1];
    A[2] += B[2];
    A[4] += B[4];
    A[5] += B[5];
    A[6] += B[6];
    A[8] += B[8];
    A[9] += B[9];
    A[10] += B[10];

    return A;
}

double *copyMatrix(double *A, double *B) {
    A[0] = B[0];
    A[1] = B[1];
    A[2] = B[2];
    A[3] = B[3];
    A[4] = B[4];
    A[5] = B[5];
    A[6] = B[6];
    A[7] = B[7];
    A[8] = B[8];
    A[9] = B[9];
    A[10] = B[10];
    A[11] = B[11];
    A[12] = B[12];
    A[13] = B[13];
    A[14] = B[14];
    A[15] = B[15];

    return A;
}

double *transpose(double *A) {
    double tmp;

    tmp = A[2];
    A[2] = A[8];
    A[8] = tmp;

    tmp = A[1];
    A[1] = A[4];
    A[4] = tmp;

    tmp = A[6];
    A[6] = A[9];
    A[9] = tmp;

    return A;
}

double *tilde(double *A, const anoid::simple::Vector v) {
    A[0] = A[5] = A[10] = A[3] = A[7] = A[11] = A[12] = A[13] = A[14] = 0.0;
    A[15] = 1.0;
    A[1] = v.getZ();
    A[2] = -v.getY();
    A[4] = -v.getZ();
    A[6] = v.getX();
    A[8] = v.getY();
    A[9] = -v.getX();

    return A;
}

---

Anoid NG © Michael Westergaard, Martin Stig Stissing, Ronni Michael Laursen, and Kristian Bisgaard Lassen