分享
 
 
 

使用模板表达式的向量类

王朝other·作者佚名  2006-01-09
窄屏简体版  字體: |||超大  

// numeric.h

#ifndef _NUMERIC_H_

#define _NUMERIC_H_

#include <memory> // memcpy

#include <iostream> // std::

using namespace std;

namespace numeric {

#define max(a,b) (((a) > (b)) ? (a) : (b))

#define min(a,b) (((a) > (b)) ? (b) : (a))

template <class T>

class expr_add

{

public:

static inline T apply(const T& a, const T& b)

{

return a + b;

}

};

template <class T>

class expr_sub

{

public:

static inline T apply(const T& a, const T& b)

{

return a - b;

}

};

template <class T>

class expr_mul

{

public:

static inline T apply(const T& a, const T& b)

{

return a * b;

}

};

template <class T>

class expr_div

{

public:

static inline T apply(const T& a, const T& b)

{

return a / b;

}

};

template <class A, class B, class Op>

class tpl_expr

{

const A& a_;

const B& b_;

public:

tpl_expr(const A& a, const B& b) : a_(a), b_(b) { }

inline double operator[](size_t i) const

{

return Op::apply(a_[i], b_[i]);

}

};

template <class B, class Op>

class tpl_expr <double, B, Op>

{

const double& a_;

const B& b_;

public:

tpl_expr(const double& a, const B& b) : a_(a), b_(b) { }

inline double operator[](size_t i) const

{

return Op::apply(a_, b_[i]);

}

};

template <class B, class Op>

class tpl_expr <int, B, Op>

{

const int& a_;

const B& b_;

public:

tpl_expr(const int& a, const B& b) : a_(a), b_(b) { }

inline double operator[](size_t i) const

{

return Op::apply(a_, b_[i]);

}

};

template <class A, class Op>

class tpl_expr <A, double, Op>

{

const A& a_;

const double& b_;

public:

tpl_expr(const A& a, const double& b) : a_(a), b_(b) { }

inline double operator[](size_t i) const

{

return Op::apply(a_[i], b_);

}

};

template <class A, class Op>

class tpl_expr <A, int, Op>

{

const A& a_;

const int& b_;

public:

tpl_expr(const A& a, const int& b) : a_(a), b_(b) { }

inline double operator[](size_t i) const

{

return Op::apply(a_[i], b_);

}

};

template <class A, class B>

tpl_expr<A, B, expr_add<double> > operator+(const A& a, const B& b)

{

return tpl_expr<A, B, expr_add<double> >(a, b);

}

template <class A, class B>

tpl_expr<A, B, expr_sub<double> > operator-(const A& a, const B& b)

{

return tpl_expr<A, B, expr_sub<double> >(a, b);

}

template <class A, class B>

tpl_expr<A, B, expr_mul<double> > operator*(const A& a, const B& b)

{

return tpl_expr<A, B, expr_mul<double> >(a, b);

}

template <class A, class B>

tpl_expr<A, B, expr_div<double> > operator/(const A& a, const B& b)

{

return tpl_expr<A, B, expr_div<double> >(a, b);

}

/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////

class vector

{

protected:

size_t dim;

double *ets;

public:

// 由已知向量个数和向量元素数组来构造一个向量

vector(size_t n, const double* const pd)

: dim(n)

{

ets = new double[dim];

memcpy(ets, pd, dim*sizeof(double));

}

vector(size_t n = 0, double d = 0.0)

: dim(n)

{

ets = new double[dim];

for (size_t i=0; i<dim; ++i) {

ets[i] = d;

}

}

vector(const vector& v)

{

dim = v.dim;

ets = new double[dim];

memcpy(ets, v.ets, sizeof(double)*dim);

}

vector& operator=(const vector& v)

{

if (this != &v) { // 防止自己拷贝自己

if (dim != v.dim) {

exit(1);

}

memcpy(ets, v.ets, sizeof(double)*dim);

}

return *this;

}

~vector()

{

delete[] ets;

}

public:

inline double operator[](size_t i) const

{

return ets[i];

}

inline double& operator[](size_t i)

{

return ets[i];

}

public:

size_t get_dim() const

{

return dim;

}

double* get_ptr() const

{

return ets;

}

double sum_element() const

{

double tmp = 0;

for (size_t i=0; i<dim; ++i) {

tmp += ets[i];

}

return tmp;

}

double min_element() const

{

double tmp = ets[0];

for (size_t i=0; i<dim; ++i) {

if (tmp > ets[i]) {

tmp = ets[i];

}

}

return tmp;

}

double max_element() const

{

double tmp = ets[0];

for (size_t i=0; i<dim; ++i) {

if (tmp < ets[i]) {

tmp = ets[i];

}

}

return tmp;

}

public:

vector& operator+()

{

return *this;

}

vector& operator-()

{

for (size_t i=0; i<dim; ++i) {

ets[i] = -ets[i];

}

return *this;

}

public:

vector& operator+=(const vector& v)

{

for (size_t i=0; i<dim; ++i) {

ets[i] += v[i];

}

return *this;

}

vector& operator-=(const vector& v)

{

for (size_t i=0; i<dim; ++i) {

ets[i] -= v[i];

}

return *this;

}

vector& operator*=(const vector& v)

{

for (size_t i=0; i<dim; ++i) {

ets[i] *= v[i];

}

return *this;

}

vector& operator/=(const vector& v)

{

for (size_t i=0; i<dim; ++i) {

ets[i] /= v[i];

}

return *this;

}

vector& operator+=(const double& d)

{

for (size_t i=0; i<dim; ++i) {

ets[i] += d;

}

return *this;

}

vector& operator-=(const double& d)

{

for (size_t i=0; i<dim; ++i) {

ets[i] -= d;

}

return *this;

}

vector& operator*=(const double& d)

{

for (size_t i=0; i<dim; ++i) {

ets[i] *= d;

}

return *this;

}

vector& operator/=(const double& d)

{

double tmp = 1/d;

for (size_t i=0; i<dim; ++i) {

ets[i] *= tmp;

}

return *this;

}

public:

template <class A, class B, class Op>

vector& operator=(const tpl_expr<A, B, Op>& expr)

{

for (size_t i=0; i<dim; ++i) {

ets[i] = expr[i];

}

return *this;

}

template <class A, class B, class Op>

vector& operator+=(const tpl_expr<A, B, Op>& expr)

{

for (size_t i=0; i<dim; ++i) {

ets[i] += expr[i];

}

return *this;

}

template <class A, class B, class Op>

vector& operator-=(const tpl_expr<A, B, Op>& expr)

{

for (size_t i=0; i<dim; ++i) {

ets[i] -= expr[i];

}

return *this;

}

template <class A, class B, class Op>

vector& operator*=(const tpl_expr<A, B, Op>& expr)

{

for (size_t i=0; i<dim; ++i) {

ets[i] *= expr[i];

}

return *this;

}

template <class A, class B, class Op>

vector& operator/=(const tpl_expr<A, B, Op>& expr)

{

for (size_t i=0; i<dim; ++i) {

ets[i] /= expr[i];

}

return *this;

}

};

};

#endif // _NUMERIC_H_

// test.cpp

#include <ctime>

#include <iostream>

#include <valarray>

using namespace std;

#include "numeric.h"

using namespace numeric;

void main()

{

int m = 10000, n=10000;

// vector x(m, 1), y(m, 2), z(m, 3);

valarray<double> x(1, m), y(2, m), z(3, m);

clock_t time;

time = clock();

for (size_t i=0; i<n; ++i) {

z = 0.5-(x - y)*1.0;

}

time = clock() - time;

cout << z[0] << endl;

cout << time/1000.0 << endl;

}

 
 
 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
2023年上半年GDP全球前十五强
 百态   2023-10-24
美众议院议长启动对拜登的弹劾调查
 百态   2023-09-13
上海、济南、武汉等多地出现不明坠落物
 探索   2023-09-06
印度或要将国名改为“巴拉特”
 百态   2023-09-06
男子为女友送行,买票不登机被捕
 百态   2023-08-20
手机地震预警功能怎么开?
 干货   2023-08-06
女子4年卖2套房花700多万做美容:不但没变美脸,面部还出现变形
 百态   2023-08-04
住户一楼被水淹 还冲来8头猪
 百态   2023-07-31
女子体内爬出大量瓜子状活虫
 百态   2023-07-25
地球连续35年收到神秘规律性信号,网友:不要回答!
 探索   2023-07-21
全球镓价格本周大涨27%
 探索   2023-07-09
钱都流向了那些不缺钱的人,苦都留给了能吃苦的人
 探索   2023-07-02
倩女手游刀客魅者强控制(强混乱强眩晕强睡眠)和对应控制抗性的关系
 百态   2020-08-20
美国5月9日最新疫情:美国确诊人数突破131万
 百态   2020-05-09
荷兰政府宣布将集体辞职
 干货   2020-04-30
倩女幽魂手游师徒任务情义春秋猜成语答案逍遥观:鹏程万里
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案神机营:射石饮羽
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案昆仑山:拔刀相助
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案天工阁:鬼斧神工
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案丝路古道:单枪匹马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:与虎谋皮
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:李代桃僵
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:指鹿为马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:小鸟依人
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:千金买邻
 干货   2019-11-12
 
推荐阅读
 
 
 
>>返回首頁<<
 
靜靜地坐在廢墟上,四周的荒凉一望無際,忽然覺得,淒涼也很美
© 2005- 王朝網路 版權所有