CUDA常用数学运算符及数据结构重定义

最新推荐文章于 2024-04-29 20:39:53 发布
最新推荐文章于 2024-04-29 20:39:53 发布
阅读量788 收藏 2
点赞数
分类专栏： CUDA 文章标签： CUDA 数学函数 向量类 GPU运算 设备主机互操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41598072/article/details/118656793
版权
这个代码段包含CUDA（Compute Unified Device Architecture）的数学函数定义，如atan2f, sqrt, cos和pow，并定义了多个向量类，如vec1b, vec3b, vec3f和vec4f，提供了加减乘除、比较和向量操作等方法。这些类支持在设备（GPU）和主机（CPU）上进行运算。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#pragma once
#include <math.h>
#include "cuda_runtime.h"


#define HOD __host__ __device__

inline HOD float dev_atan2f(float  y, float  x)
{
	return atan2(y, x);
}
inline HOD float dev_sqrt(float  x)
{
	return sqrt(x);
}
inline HOD float dev_cos(float  x)
{
	return cos(x);
}
inline HOD float dev_pow(float x, float y)
{
	return pow(x,y);
}

inline HOD float dev_acos(float x)
{
	return acos(x);
}



class vec1b
{
public:
	uchar x;
	HOD vec1b(void)
	{
		this->x = 0.0f;

	}

	HOD vec1b(const uchar& x)
	{
		this->x = x;

	}

	HOD uchar operator[](int i) const
	{
		return (&x)[i];
	}

	HOD uchar& operator[](int i)
	{
		return (&x)[i];
	}

	HOD vec1b& operator = (const vec1b &v)
	{
		x = v.x;


		return *this;
	}

	HOD vec1b operator + (const vec1b& v) const
	{
		return vec1b(x + v.x);
	}

	HOD vec1b& operator += (const vec1b& v)
	{
		x += v.x;
		return *this;
	}

	HOD vec1b operator - (const vec1b& v) const
	{
		return vec1b(x - v.x);
	}

	HOD vec1b& operator -= (const vec1b& v)
	{
		x -= v.x;
		return *this;
	}

	HOD vec1b operator * (float f) const
	{
		return vec1b(x * f);
	}

	HOD vec1b& operator *= (float f)
	{
		x *= f;


		return *this;
	}

	HOD vec1b operator / (float f) const
	{
		float inv = 1.f / f;
		return vec1b(x * inv);
	}

	HOD vec1b& operator /= (float f)
	{
		float inv = 1.f / f;
		x *= inv;
		return *this;
	}

	HOD vec1b operator-() const
	{
		return vec1b(-x);
	}

	HOD bool operator < (const vec1b& V) const
	{
		return V.x < x;
	}

	HOD bool operator > (const vec1b& V) const
	{
		return V.x > x;
	}

	HOD bool operator == (const vec1b& V) const
	{
		return V.x == x;
	}

};


class vec3b
{
public:
	uchar x, y, z;
	HOD vec3b(void)
	{
		this->x = 0.0f;
		this->y = 0.0f;
		this->z = 0.0f;
	}

	HOD vec3b(const uchar& x, const uchar& y, const uchar& z)
	{
		this->x = x;
		this->y = y;
		this->z = z;
	}

	HOD vec3b(const uchar& xyz)
	{
		this->x = xyz;
		this->y = xyz;
		this->z = xyz;
	}

	HOD uchar operator[](int i) const
	{
		return (&x)[i];
	}

	HOD uchar& operator[](int i)
	{
		return (&x)[i];
	}

	HOD vec3b& operator = (const vec3b &v)
	{
		x = v.x;
		y = v.y;
		z = v.z;

		return *this;
	}


	HOD vec3b operator + (const vec3b& v) const
	{
		return vec3b(x + v.x, y + v.y, z + v.z);
	}

	HOD vec3b& operator += (const vec3b& v)
	{
		x += v.x; y += v.y; z += v.z;
		return *this;
	}

	HOD vec3b operator - (const vec3b& v) const
	{
		return vec3b(x - v.x, y - v.y, z - v.z);
	}

	HOD vec3b& operator -= (const vec3b& v)
	{
		x -= v.x; y -= v.y; z -= v.z;
		return *this;
	}

	HOD vec3b operator * (float f) const
	{
		return vec3b(x * f, y * f, z * f);
	}

	HOD vec3b& operator *= (float f)
	{
		x *= f;
		y *= f;
		z *= f;

		return *this;
	}

	HOD vec3b operator / (float f) const
	{
		float inv = 1.f / f;
		return vec3b(x * inv, y * inv, z * inv);
	}

	HOD vec3b& operator /= (float f)
	{
		float inv = 1.f / f;
		x *= inv; y *= inv; z *= inv;
		return *this;
	}

	HOD vec3b operator-() const
	{
		return vec3b(-x, -y, -z);
	}

	HOD bool operator < (const vec3b& V) const
	{
		return V.x < x && V.y < y && V.z < z;
	}

	HOD bool operator > (const vec3b& V) const
	{
		return V.x > x && V.y > y && V.z > z;
	}

	HOD bool operator == (const vec3b& V) const
	{
		return V.x == x && V.y == y && V.z == z;
	}

};


class vec3f
{
public:
	HOD vec3f(void)
	{
		x = 0.0f;
		y = 0.0f;
		z = 0.0f;
	}

	HOD vec3f(const float& x, const float& y, const float& z)
	{
		this->x = x;
		this->y = y;
		this->z = z;
	}

	HOD vec3f(const float& xyz)
	{
		this->x = xyz;
		this->y = xyz;
		this->z = xyz;
	}

	HOD float operator[](int i) const
	{
		return (&x)[i];
	}

	HOD float& operator[](int i)
	{
		return (&x)[i];
	}

	HOD vec3f& operator = (const vec3f &v)
	{
		x = v.x;
		y = v.y;
		z = v.z;

		return *this;
	}

	HOD vec3f operator + (const vec3f& v) const
	{
		return vec3f(x + v.x, y + v.y, z + v.z);
	}

	HOD vec3f& operator += (const vec3f& v)
	{
		x += v.x; y += v.y; z += v.z;
		return *this;
	}

	HOD vec3f operator - (const vec3f& v) const
	{
		return vec3f(x - v.x, y - v.y, z - v.z);
	}

	HOD vec3f& operator -= (const vec3f& v)
	{
		x -= v.x; y -= v.y; z -= v.z;
		return *this;
	}

	HOD vec3f operator * (float f) const
	{
		return vec3f(x * f, y * f, z * f);
	}

	HOD vec3f& operator *= (float f)
	{
		x *= f;
		y *= f;
		z *= f;

		return *this;
	}

	HOD vec3f operator / (float f) const
	{
		float inv = 1.f / f;
		return vec3f(x * inv, y * inv, z * inv);
	}

	HOD vec3f& operator /= (float f)
	{
		float inv = 1.f / f;
		x *= inv; y *= inv; z *= inv;
		return *this;
	}


	HOD vec3f operator-() const
	{
		return vec3f(-x, -y, -z);
	}

	HOD bool operator < (const vec3f& V) const
	{
		return V.x < x && V.y < y && V.z < z;
	}

	HOD bool operator > (const vec3f& V) const
	{
		return V.x > x && V.y > y && V.z > z;
	}

	HOD bool operator == (const vec3f& V) const
	{
		return V.x == x && V.y == y && V.z == z;
	}

	HOD float Max(void) const
	{
		if (x >= y && x >= z)
		{
			return x;
		}
		else
		{
			if (y >= x && y >= z)
				return y;
			else
				return z;
		}
	}

	HOD float Min(void) const
	{
		if (x <= y && x <= z)
		{
			return x;
		}
		else
		{
			if (y <= x && y <= z)
				return y;
			else
				return z;
		}
	}

	HOD float LengthSquared(void) const
	{
		return x * x + y * y + z * z;
	}

	HOD float Length(void) const
	{
		return sqrtf(LengthSquared());
	}

	HOD void Normalize(void)
	{
		const float L = Length();
		x /= L;
		y /= L;
		z /= L;
	}

	HOD float Dot(const vec3f& rhs) const
	{
		return (x * rhs.x + y * rhs.y + z * rhs.z);
	}

	HOD vec3f Cross(const vec3f& rhs) const
	{
		return vec3f((y * rhs.z) - (z * rhs.y),
			(z * rhs.x) - (x * rhs.z),
			(x * rhs.y) - (y * rhs.x));
	}

	HOD void ScaleBy(const float& factor)
	{
		x *= factor;
		y *= factor;
		z *= factor;
	}

	float x, y, z;
};


class vec4f
{
public:
	HOD vec4f(void)
	{
		x = 0.0f;
		y = 0.0f;
		z = 0.0f;
		w = 0.0f;
	}

	HOD vec4f(const float& x, const float& y, const float& z, const float& w)
	{
		this->x = x;
		this->y = y;
		this->z = z;
		this->w = w;
	}

	HOD vec4f(const float& xyzw)
	{
		this->x = xyzw;
		this->y = xyzw;
		this->z = xyzw;
		this->w = xyzw;
	}

	HOD float operator[](int i) const
	{
		return (&x)[i];
	}

	HOD float& operator[](int i)
	{
		return (&x)[i];
	}

	HOD vec4f& operator = (const vec4f &v)
	{
		x = v.x;
		y = v.y;
		z = v.z;
		w = v.w;
		return *this;
	}

	HOD vec4f operator + (const vec4f& v) const
	{
		return vec4f(x + v.x, y + v.y, z + v.z, w + v.w);
	}

	HOD vec4f& operator += (const vec4f& v)
	{
		x += v.x; y += v.y; z += v.z; w += v.w;
		return *this;
	}

	HOD vec4f operator - (const vec4f& v) const
	{
		return vec4f(x - v.x, y - v.y, z - v.z, w - v.w);
	}

	HOD vec4f& operator -= (const vec4f& v)
	{
		x -= v.x; y -= v.y; z -= v.z; w -= v.w;
		return *this;
	}

	HOD vec4f operator * (float f) const
	{
		return vec4f(x * f, y * f, z * f, w*f);
	}

	HOD vec4f& operator *= (float f)
	{
		x *= f;
		y *= f;
		z *= f;
		w *= f;
		return *this;
	}

	HOD vec4f operator / (float f) const
	{
		float inv = 1.f / f;
		return vec4f(x * inv, y * inv, z * inv, w*inv);
	}

	HOD vec4f& operator /= (float f)
	{
		float inv = 1.f / f;
		x *= inv; y *= inv; z *= inv; w *= inv;
		return *this;
	}


	HOD vec4f operator-() const
	{
		return vec4f(-x, -y, -z, -w);
	}

	HOD bool operator < (const vec4f& V) const
	{
		return V.x < x && V.y < y && V.z < z;
	}

	HOD bool operator > (const vec4f& V) const
	{
		return V.x > x && V.y > y && V.z > z;
	}

	HOD bool operator == (const vec4f& V) const
	{
		return V.x == x && V.y == y && V.z == z;
	}

	HOD float Max(void) const
	{
		if (x >= y && x >= z)
		{
			return x;
		}
		else
		{
			if (y >= x && y >= z)
				return y;
			else
				return z;
		}
	}

	HOD float Min(void) const
	{
		if (x <= y && x <= z)
		{
			return x;
		}
		else
		{
			if (y <= x && y <= z)
				return y;
			else
				return z;
		}
	}

	HOD float LengthSquared(void) const
	{
		return x * x + y * y + z * z;
	}

	HOD float Length(void) const
	{
		return sqrtf(LengthSquared());
	}

	HOD void Normalize(void)
	{
		const float L = Length();
		x /= L;
		y /= L;
		z /= L;
	}

	HOD float Dot(const vec4f& rhs) const
	{
		return (x * rhs.x + y * rhs.y + z * rhs.z);
	}

	HOD vec4f Cross(const vec4f& rhs) const
	{
		return vec4f((y * rhs.z) - (z * rhs.y),
			(z * rhs.x) - (x * rhs.z),
			(x * rhs.y) - (y * rhs.x), (x * rhs.y) - (y * rhs.x));
	}

	HOD void ScaleBy(const float& factor)
	{
		x *= factor;
		y *= factor;
		z *= factor;
	}

	float x, y, z, w;
};


class vec4b
{
public:
	uchar x, y, z, w;
	HOD vec4b(void)
	{
		this->x = 0.0f;
		this->y = 0.0f;
		this->z = 0.0f;
		this->w = 0.0f;
	}

	HOD vec4b(const uchar& x, const uchar& y, const uchar& z, const uchar& w)
	{
		this->x = x;
		this->y = y;
		this->z = z;
		this->w = w;
	}

	HOD vec4b(const uchar& xyz)
	{
		this->x = xyz;
		this->y = xyz;
		this->z = xyz;
		this->w = xyz;
	}

	HOD uchar operator[](int i) const
	{
		return (&x)[i];
	}

	HOD uchar& operator[](int i)
	{
		return (&x)[i];
	}

	HOD vec4b& operator = (const vec4b &v)
	{
		x = v.x;
		y = v.y;
		z = v.z;
		w = v.w;
		return *this;
	}

	HOD vec4b operator + (const vec4b& v) const
	{
		return vec4b(x + v.x, y + v.y, z + v.z, w + v.w);
	}

	HOD vec4b& operator += (const vec4b& v)
	{
		x += v.x; y += v.y; z += v.z; w += v.w;
		return *this;
	}

	HOD vec4b operator - (const vec4b& v) const
	{
		return vec4b(x - v.x, y - v.y, z - v.z, w - v.w);
	}

	HOD vec4b& operator -= (const vec4b& v)
	{
		x -= v.x; y -= v.y; z -= v.z; w -= v.w;
		return *this;
	}

	HOD vec4b operator * (float f) const
	{
		return vec4b(x * f, y * f, z * f, w*f);
	}

	HOD vec4b& operator *= (float f)
	{
		x *= f;
		y *= f;
		z *= f;
		w *= f;
		return *this;
	}

	HOD vec4b operator / (float f) const
	{
		float inv = 1.f / f;
		return vec4b(x * inv, y * inv, z * inv, w*inv);
	}

	HOD vec4b operator-() const
	{
		return vec4b(-x, -y, -z, -w);
	}

	HOD bool operator < (const vec4b& V) const
	{
		return V.x < x && V.y < y && V.z < z&&V.w<w;
	}

	HOD bool operator > (const vec4b& V) const
	{
		return V.x > x && V.y > y && V.z > z&&V.w>w;
	}

	HOD bool operator == (const vec4b& V) const
	{
		return V.x == x && V.y == y && V.z == z && V.w == w;
	}

};

/*
template<typename T>
class HOD_vector
{
public:

HOD HOD_vector()
: first_(new T[2]), last_(first_), endl_(first_ + 2)
{
}

HOD ~HOD_vector()
{
delete[]first_;
first_ = endl_ = last_ = NULL;
}

HOD HOD_vector(const HOD_vector<T> &src)
{
{
int size = src.last_ - src.first_;
first_ = new T[src.endl_ - src.first_];
for (int i = 0; i < size; ++i)
{
first_[i] = src.first_[i];
}
last_ = first_ + size;
endl_ = first_ + (src.endl_ - src.first_);
}
}
HOD T& operator[](int i)
{
iterator _It ;
return _It[i];
}
HOD T& operator[](int i) const
{
iterator _It ;

return _It[i];
}
HOD HOD_vector<T>& operator=(const HOD_vector<T> &src)
{
if (this == &src)
{
return*this;
}
delete[]first_;
first_ = NULL;

int size = src.last_ - src.first_;
first_ = new T[src.endl_ - src.first_];
for (int i = 0; i < size; ++i)
{
first_[i] = src.first_[i];
}
last_ = first_ + size;
endl_ = first_ + (src.endl_ - src.first_);
return*this;
}


HOD bool full()
{
return first_ == endl_;
}
// 给容器末尾添加元素
HOD void push_back(const T &val)
{
if (full())
{
reSize();
}
*last_++ = val;
}
template<typename ...Args>
HOD void emplace_back(Args&&... args)
{
if (size() == capacity())
{
reallocate();
}
::new((void*)last_) T(std::forward<Args>(args)...);
++last_;
}
HOD void reallocate()
{
int maxlen = capacity() + capacity() / 2;
int len = size();
T* cur = new T[maxlen];
::memcpy(cur, first_, len * sizeof(T));
delete[] first_;
first_ = cur;
last_ = first_ + len;
endl_ = first_ + maxlen;
}


HOD int size() const { return last_ - first_; }
HOD int capacity() const { return endl_ - first_; }

// 从末尾删除元素
HOD void pop_back()
{
if (last_ == first_)
{
return;
}
--last_;
}

HOD int size()
{
return last_ - first_;
}
/*
HOD int size() const
{
return last_ - first_;
}

class iterator
{
public:
iterator(T*ptr = NULL) :_ptr(ptr) {}
//iterator(T*ptr = NULL, int pos = 0){ _ptr = _ptr + pos; }
bool operator!=(const iterator&it)
{
return _ptr != it._ptr;
}
bool operator++()
{
_ptr++;
return true;
}
T&operator*()
{
return *_ptr;
}
T operator[](int index)
{
return _ptr[index];
}
private:
mutable T*_ptr;
};
iterator begin() { return iterator(first_); }
iterator end() { return iterator(last_); }


private:
mutable T *first_; // 表数组的起始地址HOD_Point2f
mutable T *last_;  // 表示最后一个元素的后继位置的地址
mutable T *endl_;   // 末尾位置的后继位置
mutable T *w;
HOD void reSize()
{
int len = size();
T*tmp = new T[size() * 2];
int i = 0;
for (; i < len; ++i)
{
tmp[i] = first_[i];
}
delete[]first_;
first_ = tmp;
endl_ = first_ + len * 2;
last_ = first_ + len;
}

};
*/
class HOD_Point2f
{
public:
	HOD HOD_Point2f(float x = 0, float y = 0);
	HOD HOD_Point2f(const HOD_Point2f &);
	HOD bool operator==(const HOD_Point2f &) const;
	HOD bool operator!=(const HOD_Point2f &) const;
	HOD HOD_Point2f operator=(const HOD_Point2f &);
	HOD HOD_Point2f operator=(const cv::Point2f &);
	HOD HOD_Point2f operator+=(const HOD_Point2f &);
	HOD HOD_Point2f operator-=(const HOD_Point2f &);
	HOD HOD_Point2f operator+(const HOD_Point2f &) const;
	HOD HOD_Point2f operator-(const HOD_Point2f &) const;
	HOD HOD_Point2f operator*(const HOD_Point2f &) const;
	HOD HOD_Point2f operator/(int right) const {
		HOD_Point2f multi;
		multi.x = x / right;
		multi.y = y / right;
		return multi;
	}
	HOD float dot(const HOD_Point2f &) const;
	float x;
	float y;
};

HOD inline HOD_Point2f::HOD_Point2f(float a, float b)
{
	x = a;
	y = b;
}
HOD inline HOD_Point2f::HOD_Point2f(const HOD_Point2f &a)
{
	x = a.x;
	y = a.y;
}
HOD inline bool HOD_Point2f::operator==(const HOD_Point2f &right)const
{
	if (x == right.x && y == right.y)
		return true;
	else return false;
}
HOD inline bool HOD_Point2f::operator!=(const HOD_Point2f &right) const
{
	if (x == right.x && y == right.y)
		return false;
	else return true;
}
HOD inline HOD_Point2f HOD_Point2f::operator+=(const HOD_Point2f &right)
{
	x += right.x;
	y += right.y;
	return *this;
}
HOD inline HOD_Point2f HOD_Point2f::operator-=(const HOD_Point2f &right)
{
	x -= right.x;
	y -= right.y;
	return *this;
}
HOD inline HOD_Point2f HOD_Point2f::operator=(const HOD_Point2f &right)
{
	x = right.x;
	y = right.y;
	return *this;
}
HOD inline HOD_Point2f HOD_Point2f::operator=(const cv::Point2f &right)
{
	x = right.x;
	y = right.y;
	return *this;
}

HOD inline HOD_Point2f HOD_Point2f::operator+(const HOD_Point2f &right)const
{
	HOD_Point2f plus;
	plus.x = x + right.x;
	plus.y = y + right.y;
	return plus;
}
HOD inline HOD_Point2f HOD_Point2f::operator-(const HOD_Point2f &right)const
{
	HOD_Point2f minus;
	minus.x = x - right.x;
	minus.y = y - right.y;
	return minus;
}
HOD inline HOD_Point2f HOD_Point2f::operator*(const HOD_Point2f &right)const
{
	HOD_Point2f multi;
	multi.x = x * right.x;
	multi.y = y * right.y;
	return multi;
}
HOD inline float HOD_Point2f::dot(const HOD_Point2f &right) const
{
	HOD_Point2f multi;

	return (multi.x*right.x + multi.y*right.y);
}

HOD inline float Norm(const HOD_Point2f &right)
{

	return std::sqrt(right.x*right.x + right.y*right.y);
}




class HOD_Point2i
{
public:
	HOD HOD_Point2i(int x = 0, int y = 0);
	HOD HOD_Point2i(const HOD_Point2i &);
	HOD bool operator==(const HOD_Point2i &) const;
	HOD bool operator!=(const HOD_Point2i &) const;
	HOD HOD_Point2i operator=(const HOD_Point2i &);
	HOD HOD_Point2i operator=(const cv::Point2i &);
	HOD HOD_Point2i operator+=(const HOD_Point2i &);
	HOD HOD_Point2i operator-=(const HOD_Point2i &);
	HOD HOD_Point2i operator+(const HOD_Point2i &) const;
	HOD HOD_Point2i operator-(const HOD_Point2i &) const;
	HOD HOD_Point2i operator*(const HOD_Point2i &) const;
	HOD HOD_Point2i operator/(int right) const {
		HOD_Point2i multi;
		multi.x = x / right;
		multi.y = y / right;
		return multi;
	}
	HOD int dot(const HOD_Point2i &) const;
	int x;
	int y;
};

HOD inline HOD_Point2i::HOD_Point2i(int a, int b)
{
	x = a;
	y = b;
}
HOD inline HOD_Point2i::HOD_Point2i(const HOD_Point2i &a)
{
	x = a.x;
	y = a.y;
}
HOD inline bool HOD_Point2i::operator==(const HOD_Point2i &right)const
{
	if (x == right.x && y == right.y)
		return true;
	else return false;
}
HOD inline bool HOD_Point2i::operator!=(const HOD_Point2i &right) const
{
	if (x == right.x && y == right.y)
		return false;
	else return true;
}
HOD inline HOD_Point2i HOD_Point2i::operator+=(const HOD_Point2i &right)
{
	x += right.x;
	y += right.y;
	return *this;
}
HOD inline HOD_Point2i HOD_Point2i::operator-=(const HOD_Point2i &right)
{
	x -= right.x;
	y -= right.y;
	return *this;
}
HOD inline HOD_Point2i HOD_Point2i::operator=(const HOD_Point2i &right)
{
	x = right.x;
	y = right.y;
	return *this;
}
HOD inline HOD_Point2i HOD_Point2i::operator=(const cv::Point2i &right)
{
	x = right.x;
	y = right.y;
	return *this;
}

HOD inline HOD_Point2i HOD_Point2i::operator+(const HOD_Point2i &right)const
{
	HOD_Point2i plus;
	plus.x = x + right.x;
	plus.y = y + right.y;
	return plus;
}
HOD inline HOD_Point2i HOD_Point2i::operator-(const HOD_Point2i &right)const
{
	HOD_Point2i minus;
	minus.x = x - right.x;
	minus.y = y - right.y;
	return minus;
}
HOD inline HOD_Point2i HOD_Point2i::operator*(const HOD_Point2i &right)const
{
	HOD_Point2i multi;
	multi.x = x * right.x;
	multi.y = y * right.y;
	return multi;
}
HOD inline int HOD_Point2i::dot(const HOD_Point2i &right) const
{
	HOD_Point2f multi;

	return (multi.x*right.x + multi.y*right.y);
}

HOD inline int Norm(const HOD_Point2i &right)
{

	return std::sqrt(right.x*right.x + right.y*right.y);
}

HOD struct Point2Df
{
	float x, y;
};


//类定义：二维向量
class Vector2d
{
public:
	double x_;
	double y_;

public:
	HOD Vector2d(double x, double y) :x_(x), y_(y) {}
	HOD Vector2d() :x_(0), y_(0) {}

	//二维向量叉乘, 叉乘的结果其实是向量，方向垂直于两个向量组成的平面，这里我们只需要其大小和方向
	HOD double CrossProduct(const Vector2d vec)
	{
		return x_*vec.y_ - y_*vec.x_;
	}

	//二维向量点积
	HOD double DotProduct(const Vector2d vec)
	{
		return x_ * vec.x_ + y_ * vec.y_;
	}

	//二维向量减法
	HOD Vector2d Minus(const Vector2d vec) const
	{
		return Vector2d(x_ - vec.x_, y_ - vec.y_);
	}

	//判断点M,N是否在直线AB的同一侧
	HOD static bool IsPointAtSameSideOfLine(const Vector2d &pointM, const Vector2d &pointN,
		const Vector2d &pointA, const Vector2d &pointB)
	{
		Vector2d AB = pointB.Minus(pointA);
		Vector2d AM = pointM.Minus(pointA);
		Vector2d AN = pointN.Minus(pointA);

		//等于0时表示某个点在直线上
		return AB.CrossProduct(AM) * AB.CrossProduct(AN) >= 0;
	}
};
【Python 语法】Python 神经网络项目常用语法
一杯水果茶！足矣~
11-18 1914
Python 项目常用语法
CUDA数据结构体在GPU和CPU之间的传输
Alfafar的博客
03-21 2203
参照《cuda c编程权威指南》上写出的，在CPU和GPU互相传输结构体。 #include "cuda_runtime.h" #include "device_launch_parameters.h" #include <stdio.h> #include<stdlib.h> #define maxnumber 100 typedef struct node { int x[maxnumber]; int y[maxnumber]; int test[maxnumbe
CUDA修饰符，运算符＜＜＜＞＞＞及变量的介绍
tangbenjun的博客
09-15 7260
1．函数类型限定符：用来确定函数是在 CPU 还是在 GPU 上执行，以及这个函数是从CPU 调用还是从 GPU 调用。     １．１ __device__ ， 表示从 GPU 上调用，在 GPU 上执行； 也就是说其可以被__global__ 或者__device__修饰的函数调用。此限定符修饰的函数使用有限制，比如在 G80/GT200 架构上不能使用递归，不能使用函数指针等。
CUDA_Math_API.pdf
12-11
cuda api查询
GPU基本介绍
计算机视觉小菜鸟的专栏
06-05 1万+
基本概念： GPU: Graphic Processing Unit;图形处理单元； GPGPU: General Purpose computations on GPU；通用计算图形处理单元； CPU与GPU的相同点： （1）都是计算机体系结构中的重要组成部分； （2）都是超大规模集成电路元件； （3）都能够完成浮点运能功能； CPU与GPU的不同之处： （1）GPU的设计目
在cuda中,使用自定义结构体,
闲暇余客
08-25 4350
在使用GPU加速中,有时需要传入结构体来进行统一计算,完后再同意导出,所以,在参考了一些资料,做了一下测试, 并记录,以供以后继续看
Matlab数据结构进阶：构建地震数据处理的高效框架
本文系统地介绍和探讨了Matlab数据结构的基础知识、地震数据处理的理论和应用以及优化技巧。首先，概述了Matlab数据结构的基础知识，为理解后续章节打下基础。接着，详细介绍了地震数据的特点、处理需求、预处理步骤...
光线追踪渲染实战（二）：BVH 加速遍历结构
AKGWSB 's blog
07-12 1万+
BVH 全称 Bounding Volume Hierarchy，即层次包围盒，是一种场景管理的数据结构。BVH 用 AABB 的盒子（碰撞箱）包围一组三角面片。 光线要击中盒子中的三角形的必要条件，是光线击中盒子。如果光线没有击中盒子，那么必定不会击中盒子里面的所有三角形。 基于这个规律剔除三角形，从而达到减少求交次数的目的，这就是 BVH 这种数据结构的优势
MATLAB数学工具箱入门指南
MATLAB，作为数学计算和工程分析的重量级选手，拥有一个强大的数学工具箱，为科研人员和工程师提供了一站式的解决方案。本章节将为读者提供一个关于MATLAB数学工具箱的全面概览，带领大家从宏观角度理解MATLAB数学...
阵列除法器设计的数学基础：算法优化的4大核心原理
在这一章节中，我们将从基础的角度来探讨阵列除法器的设计和它的重要性，为后续章节对算法优化、数学模型和实践应用的深入讨论奠定基础。 ## 1.1 阵列除法器的定义与作用 阵列除法器是一种并行计算架构，它能
CUDA 常用的函数
07-19
CUDA 常用的函数CUDA 常用的函数CUDA 常用的函数CUDA 常用的函数CUDA 常用的函数CUDA 常用的函数CUDA 常用的函数
CUDA——可用于核函数中的CUDA基本数学运算函数总结
Irving.Gao的博客
11-22 3688
对于单、双浮点类型和整型的数学函数，用法基本和math.h库的用法相同，举几个例子：函数功能CPU MathCUDA Math单精度求平方单精度求根号可以看出基本都是一一对应的。其他主要用法还是参考手册~
CUDA架构介绍与设计模式解析
最新发布
a284365的博客
04-29 4309
1CUDA 是 NVIDIA 于 2006 年推出的通用并行计算架构，经过多年发展，已成为 GPU 计算的重要标准。
CUDA与结构体
【黑键】
06-17 1045
为了自定义数据结构方便读取信息. 需要自己定义数据结构 后续工作则可以使用 CUDA流 来缓解 CPU与GPU 数据交互的问题 [CUDA GPU编程中使用结构体传递函数参数](https://blog.csdn.net/u013701860/article/details/52605137）...
cuda学算法 1
LiQuKanNaShiYu的博客
05-13 252
标题 cuda学算法 1 cuda-algorithm 主要目的是学习算法和cuda。源码地址 本文实现了基本的cuda数组 写了一个类似于c++ vector的简单类实现cuda内存管理，重载运算符号[] 使之能便捷访问二维数组 template <class T> struct cuBase { T *devPtr; uint64_t cap; uint64_t size; //拷贝构造函数 cuBase(const cuBase &lth
CUDA编程02——向量相加
不少年快跑的专栏
08-10 1129
预备知识 先来看一张图： Host：指的是CPU端。 Device：指的是GPU端。 Device上有很多执行单元，也就是上图中的Thread。每个Thread可以执行一个核函数（在GPU上执行的函数）。 Device上包含若干个网格（Grid），每个网格中包含若干个块（Block），每个块内包含若干个线程（Thread）。在上一篇博客中，下面这些变量就是和这三个名词相关的： Maximum number of threads per SM: 2048 M.
CUDA数学库
吴建明wujianming_110117
02-20 1823
CUDA数学库 高性能数学例程 CUDA数学库是经过行业验证的，高度准确的标准数学函数的集合。只需在源代码中添加“ #include math.h”，即可用于任何CUDA C或CUDA C ++应用程序，CUDA Math库可确保应用程序受益于针对每种NVIDIA GPU架构进行了优化的高性能数学例程。 数字密集型GPU加速的应用程序和库，包括NVIDIA提供的所有CUDA库，都依靠CUDA Math库来提供突破性的结果。 主要特点 • 完全支持所有C99标准浮点和双数学功能 • IEEE-754对浮点，双
Nvidia CUDA初级教程7 CUDA编程二
weixin_44966641的博客
01-29 1038
Nvidia CUDA初级教程7 CUDA编程二 视频：https://www.bilibili.com/video/BV1kx411m7Fk?p=8 讲师：周斌 本节内容： 内置类型和函数 Built-ins and functions 线程同步 Synchronizing 线程调度 Scheduling threads 存储模型 Memory model 重访 Matrix multiply 原子函数 Atomic functions 函数的声明 执行 调用 __global_
atan2相关知识汇总
热门推荐
weixin_42142612的博客
07-09 5万+
1.atan2的含义C 语言里 double atan2(double y,double x) 返回的是原点至点(x,y)的方位角，即与 x 轴的夹角。返回值的单位为弧度，取值范围为（-π, π]。结果为正表示从 X 轴逆时针旋转的角度，结果为负表示从 X 轴顺时针旋转的角度。若要用度表示反正切值，请将结果再乘以 180/π。另外要注意的是，函数atan2(y,x)中参数的顺序是倒置的，atan2...
CUDA编程模型与GPU数据挖掘：谱聚类CUDA实现解析
"CUDA编程模型及其在数据挖掘领域的应用" CUDA是一种由NVIDIA公司推出的通用并行计算架构，它提供了一种高效的编程模型，使得程序员能够利用GPU（图形处理器）的强大计算能力，来解决高性能计算和大规模数据处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AplusX

踩坑不易，打个赏呗~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值