db5ff8ec4a
git-svn-id: https://reactphysics3d.googlecode.com/svn/trunk@392 92aac97c-a6ce-11dd-a772-7fcde58d38e6
175 lines
8.4 KiB
C++
175 lines
8.4 KiB
C++
/********************************************************************************
|
|
* ReactPhysics3D physics library, http://code.google.com/p/reactphysics3d/ *
|
|
* Copyright (c) 2010 Daniel Chappuis *
|
|
*********************************************************************************
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy *
|
|
* of this software and associated documentation files (the "Software"), to deal *
|
|
* in the Software without restriction, including without limitation the rights *
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell *
|
|
* copies of the Software, and to permit persons to whom the Software is *
|
|
* furnished to do so, subject to the following conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in *
|
|
* all copies or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE *
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, *
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN *
|
|
* THE SOFTWARE. *
|
|
********************************************************************************/
|
|
|
|
#ifndef VECTOR_H
|
|
#define VECTOR_H
|
|
|
|
// Libraries
|
|
#include "Vector3D.h"
|
|
#include "../typeDefinitions.h"
|
|
#include "mathematics_functions.h"
|
|
#include "exceptions.h"
|
|
#include <cmath>
|
|
#include <cassert>
|
|
#include <iostream>
|
|
|
|
|
|
// ReactPhysics3D namespace
|
|
namespace reactphysics3d {
|
|
|
|
/* -------------------------------------------------------------------
|
|
Class Vector :
|
|
This class represents a Vector.
|
|
-------------------------------------------------------------------
|
|
*/
|
|
class Vector {
|
|
private :
|
|
double* tab; // Array of the vector's components
|
|
uint nbComponent; // number of components in the vector
|
|
|
|
public :
|
|
Vector(); // Constructor without argument
|
|
Vector(int n) throw(std::invalid_argument); // Constructor of the class Vector
|
|
Vector(const Vector& vector); // Copy-constructor of the class Vector
|
|
Vector(const Vector3D& vector3d); // Conversion from Vector3D to Vector
|
|
virtual ~Vector(); // Destructor of the class Vector
|
|
double getValue(int n) const throw(std::invalid_argument); // Get a component of the vector
|
|
void setValue(int n, double value) throw(std::invalid_argument); // Set the value of a component of the vector
|
|
int getNbComponent() const; // Get the number of components in the vector
|
|
void initWithValue(double value); // Init all the elements with a given value
|
|
double length() const; // Get the length of the vector
|
|
Vector getUnit() const throw(MathematicsException); // Return the corresponding unit vector
|
|
double scalarProduct(const Vector& vector) const throw(MathematicsException); // Scalar product of two vectors
|
|
Vector crossProduct(const Vector& vector) const throw(MathematicsException); // Cross product of two vectors (in 3D only)
|
|
void fillInSubVector(uint index, const Vector& subVector); // Replace a part of the current vector with another sub-vector
|
|
Vector getSubVector(uint index, uint nbElements) const throw(std::invalid_argument); // Return a sub-vector of the current vector
|
|
void setVector(const Vector& vector);
|
|
bool isUnit() const; // Return true if the vector is unit and false otherwise
|
|
void changeSize(uint newSize);
|
|
|
|
// --- Overloaded operators --- //
|
|
Vector operator+(const Vector& vector) const throw(MathematicsException); // Overloaded operator for addition
|
|
Vector operator-(const Vector& vector) const throw(MathematicsException); // Overloaded operator for substraction
|
|
Vector operator*(double number) const; // Overloaded operator for multiplication with a number
|
|
Vector& operator=(const Vector& vector) throw(MathematicsException); // Overloaded operator for the assignement to a Vector
|
|
bool operator==(const Vector& vector) const throw(MathematicsException); // Overloaded operator for the equality condition
|
|
};
|
|
|
|
|
|
// ------ Definition of inlines functions ------ //
|
|
|
|
// Method to get the value of a component of the vector (inline)
|
|
inline double Vector::getValue(int n) const throw(std::invalid_argument) {
|
|
// Check the argument
|
|
if (n>=0 && n<nbComponent) {
|
|
// Return the value of the component
|
|
return tab[n];
|
|
}
|
|
else {
|
|
// Throw an exception because of the wrong argument
|
|
throw std::invalid_argument("The argument is outside the bounds of the Vector");
|
|
}
|
|
}
|
|
|
|
// Method to set the value of a component of the vector
|
|
inline void Vector::setValue(int n, double value) throw(std::invalid_argument) {
|
|
// Check the argument
|
|
if (n >= 0 && n<nbComponent) {
|
|
// Set the value
|
|
tab[n] = value;
|
|
}
|
|
else {
|
|
// Throw an exception because of the wrong argument
|
|
throw std::invalid_argument("Exception : The argument is outside the bounds of the Vector");
|
|
}
|
|
}
|
|
|
|
// Method to get the number of components in the vector (inline)
|
|
inline int Vector::getNbComponent() const {
|
|
// Return the number of components in the vector
|
|
return nbComponent;
|
|
}
|
|
|
|
// Method to get the length of the vector
|
|
inline double Vector::length() const {
|
|
// Compute the length of the vector
|
|
double sum = 0.0;
|
|
for(int i=0; i<nbComponent; ++i) {
|
|
sum = sum + tab[i] * tab[i];
|
|
}
|
|
|
|
// Return the length of the vector
|
|
return sqrt(sum);
|
|
}
|
|
|
|
// Init all the elements with a given value
|
|
inline void Vector::initWithValue(double value) {
|
|
for (uint i=0; i<nbComponent; i++) {
|
|
tab[i] = value;
|
|
}
|
|
}
|
|
|
|
// Replace a part of the current vector with another sub-vector.
|
|
// The argument "rowIndex" is the row index where the subVector starts.
|
|
inline void Vector::fillInSubVector(uint rowIndex, const Vector& subVector) {
|
|
assert(nbComponent-rowIndex >= subVector.nbComponent);
|
|
|
|
// For each value of the sub-vector
|
|
for (uint i=0; i<subVector.nbComponent; ++i) {
|
|
tab[rowIndex + i] = subVector.getValue(i);
|
|
}
|
|
}
|
|
|
|
// Return a sub-vector of the current vector
|
|
inline Vector Vector::getSubVector(uint index, uint nbElements) const throw(std::invalid_argument) {
|
|
// Check if the arguments are valid
|
|
if (index < 0 || index+nbElements > nbComponent) {
|
|
throw std::invalid_argument("Error : arguments are out of bounds");
|
|
}
|
|
|
|
// Compute the sub-vector
|
|
Vector subVector(nbElements);
|
|
for (uint i=0, j=index; i<nbElements; i++, j++) {
|
|
subVector.tab[i] = tab[j];
|
|
}
|
|
|
|
// Return the sub-vector
|
|
return subVector;
|
|
}
|
|
|
|
// Return true if the vector is unit and false otherwise
|
|
inline bool Vector::isUnit() const {
|
|
return approxEqual(1.0, length());
|
|
}
|
|
|
|
// Overloaded operator for multiplication between a number and a Vector (inline)
|
|
inline Vector operator*(double number, const Vector& vector) {
|
|
// Compute and return the result
|
|
return vector * number;
|
|
}
|
|
|
|
} // End of the ReactPhysics3D namespace
|
|
|
|
#endif
|