www.pudn.com > Image_segment.rar > Vector.h

//Copyright (c) 2004-2005, Baris Sumengen 
//All rights reserved. 
// 
// CIMPL Matrix Performance Library 
// 
//Redistribution and use in source and binary 
//forms, with or without modification, are 
//permitted provided that the following 
//conditions are met: 
// 
//    * No commercial use is allowed.  
//    This software can only be used 
//    for non-commercial purposes. This  
//    distribution is mainly intended for 
//    academic research and teaching. 
//    * Redistributions of source code must 
//    retain the above copyright notice, this 
//    list of conditions and the following 
//    disclaimer. 
//    * Redistributions of binary form must 
//    mention the above copyright notice, this 
//    list of conditions and the following 
//    disclaimer in a clearly visible part  
//    in associated product manual,  
//    readme, and web site of the redistributed  
//    software. 
//    * Redistributions in binary form must 
//    reproduce the above copyright notice, 
//    this list of conditions and the 
//    following disclaimer in the 
//    documentation and/or other materials 
//    provided with the distribution. 
//    * The name of Baris Sumengen may not be 
//    used to endorse or promote products 
//    derived from this software without 
//    specific prior written permission. 
// 
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT 
//HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
//EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT 
//NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
//MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
//PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
//CONTRIBUTORS BE LIABLE FOR ANY 
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
//EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
//DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
//HOWEVER CAUSED AND ON ANY THEORY OF 
//LIABILITY, WHETHER IN CONTRACT, STRICT 
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
//OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
//OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
//POSSIBILITY OF SUCH DAMAGE. 
 
 
 
#pragma once 
#ifndef VECTOR_H 
#define VECTOR_H 
 
#include  
 
using std::cout; 
using std::cerr; 
using std::endl; 
using std::ostream; 
using std::right; 
using std::fixed; 
 
#include  
 
using std::setw; 
 
#include  
 
#include  
 
 
#include "cimpl.h" 
 
 
#include  
 
using std::ostringstream; 
 
#include  
using std::numeric_limits; 
 
using namespace std; 
 
 
namespace CIMPL 
{ 
 
 
// forward declaration 
//template< class T > class Array; 
template< class T > class Matrix; 
template< class T > class Vector; 
 
 
/// \brief 1-D Vector class. 
template< class T > 
class Vector 
{ 
	//friend class Array; 
	friend class Matrix; 
 
 
protected: 
	T *data; 
	int length; 
	bool memoryManaged; 
	Cleaner *clean;   // Reference counting Garbage collector. 
 
 
public: 
	Vector(void); 
	explicit Vector(int l); 
	Vector(string str); 
	Vector(int l, T init); 
	Vector(T* _data, int l); // creates unmanaged memory 
	Vector(Vector &v); 
	 
	~Vector(void); 
	void Set(T* _data, const int l); // creates unmanaged memory 
 
	void Clean(); 
 
	const T* DataPtr() const; 
	T* Data(); 
 
	Vector Clone() const; 
	Vector Slice(int start, int end); 
	Vector Slice(string str); 
 
	const bool IsMemoryManaged() const; 
 
	const int Length() const; 
	const int Numel() const; 
	void Init(const T init); 
	Vector& Rand(const double max); 
	static Vector Rand(const int l, const double max); 
 
	void ReadFromVector(const Vector& m, const int index=0); 
 
 
	static Vector Cat(Vector& m1, Vector& m2); 
 
	static Vector Ones(int side); 
	static Vector Zeros(int side); 
 
 
	static T Inner(Vector& m1, Vector& m2); 
 
	// Boolean Operations... 
	static Vector And(Vector& m1, Vector& m2); 
	static Vector Or(Vector& m1, Vector& m2); 
	static Vector Lt(Vector& m1, Vector& m2); 
	static Vector Gt(Vector& m1, Vector& m2); 
	static Vector Le(Vector& m1, Vector& m2); 
	static Vector Ge(Vector& m1, Vector& m2); 
	static Vector Eq(Vector& m1, Vector& m2); 
	static Vector Ne(Vector& m1, Vector& m2); 
 
	// Boolean Operations with value type... 
	static Vector And(Vector& m, T v); 
	static Vector Or(Vector& m, T v); 
	static Vector Lt(Vector& m, T v); 
	static Vector Gt(Vector& m, T v); 
	static Vector Le(Vector& m, T v); 
	static Vector Ge(Vector& m, T v); 
	static Vector Eq(Vector& m, T v); 
	static Vector Ne(Vector& m, T v); 
 
 
 
// Add vector to another vector 
	static Vector Add(Vector& m1, Vector& m2); 
	static Vector Subtract(Vector& m1, Vector& m2); 
	static Vector Multiply(Vector& m1, Vector& m2); 
	static Vector Divide(Vector& m1, Vector& m2); 
 
// Add value to another vector 
	static Vector Add(Vector& m1, T v2); 
	static Vector Subtract(Vector& m1, T v2); 
	static Vector Subtract(T v2, Vector& m1); 
	static Vector Multiply(Vector& m1, T v2); 
	static Vector Divide(Vector& m1, T v2); 
	static Vector Divide(T v2, Vector& m1); 
 
 
// Add vector to "this" vector 
	Vector& Add(Vector& m); 
	Vector& Subtract(Vector& m); 
	Vector& Multiply(Vector& m); 
	Vector& Divide(Vector& m); 
 
// Add value to "this" vector 
	Vector& Add(T v); 
	Vector& Subtract(T v); 
	Vector& Multiply(T v); 
	Vector& Divide(T v); 
 
 
//OPERATORS 
	Vector& operator= (Vector& m); 
	Vector& operator= (Matrix& m); 
	//Vector& operator= (Array& m); 
 
	Vector& operator= (string str); 
 
	Vector operator+ (); 
	Vector operator- (); 
	Vector operator! (); 
 
	friend Matrix operator, (Vector& m1, Vector& m2) 
	{ 
		return Matrix::Cat(2,m1, m2); 
	} 
	 
 
 
 
	friend ostream& operator<< (ostream& output, const Vector& v) 
	{ 
		int lm = v.Length(); 
		int rowNoWidth = (int)log10((double)(lm-1))+2; 
		int maxLength  = 1; 
		for(int i=0; imaxLength) 
			{ 
				maxLength = l; 
			} 
		} 
 
		output << typeid(v).name() << " of size " << v.length << endl; 
		output << "----------------------" << endl; 
		for(int i=0;i operator() (int start, int end); 
	Vector operator() (string str); 
 
	Vector operator() (Vector& ind); 
	 
	T& Elem(const int i); 
	T& ElemNC(const int i); // No bounds check 
	 
	 
	// Vector to Vector inner product 
	friend T operator& (Vector& m1, Vector& m2) 
	{ 
		return Vector::Inner(m1, m2); 
	} 
	 
	 
	// Boolean operations 
	friend Vector operator&& (Vector& m1, Vector& m2) 
	{ 
		return Vector::And(m1, m2); 
	} 
 
	friend Vector operator|| (Vector& m1, Vector& m2) 
	{ 
		return Vector::Or(m1, m2); 
	} 
 
	friend Vector operator< (Vector& m1, Vector& m2) 
	{ 
		return Vector::Lt(m1, m2); 
	} 
 
	friend Vector operator> (Vector& m1, Vector& m2) 
	{ 
		return Vector::Gt(m1, m2); 
	} 
 
	friend Vector operator<= (Vector& m1, Vector& m2) 
	{ 
		return Vector::Le(m1, m2); 
	} 
 
	friend Vector operator>= (Vector& m1, Vector& m2) 
	{ 
		return Vector::Ge(m1, m2); 
	} 
 
	friend Vector operator== (Vector& m1, Vector& m2) 
	{ 
		return Vector::Eq(m1, m2); 
	} 
 
	friend Vector operator!= (Vector& m1, Vector& m2) 
	{ 
		return Vector::Ne(m1, m2); 
	} 
 
 
	// Boolean operations with value type 
	friend Vector operator&& (Vector& m, T v) 
	{ 
		return Vector::And(m, v); 
	} 
	friend Vector operator&& (T v, Vector& m) 
	{ 
		return Vector::And(m, v); 
	} 
 
	friend Vector operator|| (Vector& m, T v) 
	{ 
		return Vector::Or(m, v); 
	} 
	friend Vector operator|| (T v, Vector& m) 
	{ 
		return Vector::Or(m, v); 
	} 
 
	friend Vector operator< (Vector& m, T v) 
	{ 
		return Vector::Lt(m, v); 
	} 
	friend Vector operator< (T v, Vector& m) 
	{ 
		return Vector::Gt(m, v); 
	} 
 
	friend Vector operator> (Vector& m, T v) 
	{ 
		return Vector::Gt(m, v); 
	} 
	friend Vector operator> (T v, Vector& m) 
	{ 
		return Vector::Lt(m, v); 
	} 
 
	friend Vector operator<= (Vector& m, T v) 
	{ 
		return Vector::Le(m, v); 
	} 
	friend Vector operator<= (T v, Vector& m) 
	{ 
		return Vector::Ge(m, v); 
	} 
 
	friend Vector operator>= (Vector& m, T v) 
	{ 
		return Vector::Ge(m, v); 
	} 
	friend Vector operator>= (T v, Vector& m) 
	{ 
		return Vector::Le(m, v); 
	} 
 
	friend Vector operator== (Vector& m, T v) 
	{ 
		return Vector::Eq(m, v); 
	} 
	friend Vector operator== (T v, Vector& m) 
	{ 
		return Vector::Eq(m, v); 
	} 
 
	friend Vector operator!= (Vector& m, T v) 
	{ 
		return Vector::Ne(m, v); 
	} 
	friend Vector operator!= (T v, Vector& m) 
	{ 
		return Vector::Ne(m, v); 
	} 
 
 
 
// Add Vector to another Vector 
	friend Vector operator+ (Vector& m1, Vector& m2) 
	{ 
		return Vector::Add(m1, m2); 
	} 
 
	friend Vector operator- (Vector& m1, Vector& m2) 
	{ 
		return Vector::Subtract(m1, m2); 
	} 
 
	friend Vector operator* (Vector& m1, Vector& m2) 
	{ 
		return Vector::Multiply(m1, m2); 
	} 
 
	friend Vector operator/ (Vector& m1, Vector& m2) 
	{ 
		return Vector::Divide(m1, m2); 
	} 
 
 
// Add value to another matrix 
	friend Vector operator+ (Vector& m, T v) 
	{ 
		return Vector::Add(m, v); 
	} 
 
	friend Vector operator+ (T v, Vector& m) 
	{ 
		return Vector::Add(m, v); 
	} 
 
	friend Vector operator- (Vector& m, T v) 
	{ 
		return Vector::Subtract(m, v); 
	} 
 
	friend Vector operator- (T v, Vector& m) 
	{ 
		return Vector::Subtract(v, m); 
	} 
 
	friend Vector operator* (Vector& m, T v) 
	{ 
		return Vector::Multiply(m, v); 
	} 
 
	friend Vector operator* (T v, Vector& m) 
	{ 
		return Vector::Multiply(m, v); 
	} 
 
	friend Vector operator/ (Vector& m, T v) 
	{ 
		return Vector::Divide(m, v); 
	} 
 
	friend Vector operator/ (T v, Vector& m) 
	{ 
		return Vector::Divide(v, m); 
	} 
 
 
 
 
// Add inline 
	Vector& operator+= (Vector& m); 
	Vector& operator-= (Vector& m); 
	Vector& operator*= (Vector& m); 
	Vector& operator/= (Vector& m); 
 
	Vector& operator+= (T v); 
	Vector& operator-= (T v); 
	Vector& operator*= (T v); 
	Vector& operator/= (T v); 
 
	 
// TYPE CONVERSIONS 
	//Vector(Array &m); 
	Vector(Matrix &m); 
 
}; 
 
 
 
 
#include "./Vector.inl" 
 
 
}; //namespace 
 
 
 
#endif