精华内容
下载资源
问答
  • c++向量单位化
    千次阅读
    2015-08-09 22:52:00

    向量是有方向和大小的量,所谓单位化就是保持其方向不变,将其长度化为1  有一向量a(标箭头),其长度为绝对值a,单位化为(a/绝对值a)

    公式:

    向量a的坐标为(x,y),那么其长度(又称为模)为:√(x²+y²)。单位化后为(x,y)/√(x²+y²)或(x/√(x²+y²) , y/√(x²+y²))

     

    代码实现方式:

    public void normalized2D(Vector3 pos) 
        {
            Vector3 temp = Vector3.zero;
    
            temp.x = (float)(pos.x / (Math.Sqrt(pos.x * pos.x + pos.y * pos.y + pos.z * pos.z)));
            temp.y = (float)(pos.y / (Math.Sqrt(pos.x * pos.x + pos.y * pos.y + pos.z * pos.z)));
            temp.z = (float)(pos.z / (Math.Sqrt(pos.x * pos.x + pos.y * pos.y + pos.z * pos.z)));
    
            Debug.Log(temp);
        }
    
    
        public void normalized3D(Vector2 pos)
        {
            Vector2 temp = Vector2.zero;
    
            temp.x = (float)(pos.x / (Math.Sqrt(pos.x * pos.x + pos.y * pos.y)));
            temp.y = (float)(pos.y / (Math.Sqrt(pos.x * pos.x + pos.y * pos.y)));
    
            Debug.Log(temp);
        }

    转载于:https://www.cnblogs.com/plateFace/p/4716649.html

    更多相关内容
  • 下完之后惊呆了,但是有些东西一定要用你的耐心和意志力去完成
  • C++小例子——01 向量类myVector

    千次阅读 2020-06-10 10:12:11
    C++定义了一个向量类myVector,其包含三个成员变量(x,y,z),可通过三个分量来构造,也可通过另一个myVector对象来构造,重载操作符+、-、*、/来完成相关运算,重载赋值符=,重载输出流来实现输出,定义友元函数dot...

    向量(vector) a ⃗ = [ x , y , z ] \vec a=[x,y,z] a =[x,y,z]应用较广,比如节点的坐标 x ⃗ = [ x , y , z ] \vec x=[x,y,z] x =[x,y,z]、面的面积矢量 S ⃗ f = [ S f x , S f y , S f z ] \vec{S}_f=[Sf_x,Sf_y,Sf_z] S f=[Sfx,Sfy,Sfz],面空间速度矢量 u ⃗ = [ u , v , w ] \vec u=[u,v,w] u =[u,v,w]等,都离不开它。同时,向量还有点乘、叉乘、求模(也称为幅值或二范数)的运算,以及向量与向量或标量的加减操作、向量与标量的乘除运算等。那么,咱们可以用C++定义一个向量类myVector,其包含三个成员变量 x , y , z x,y,z x,y,z,可通过三个分量来构造,也可通过另一个myVector对象来构造,重载操作符+、-、*、/来完成相关运算,重载赋值符=,重载输出流<<来实现输出,定义友元函数dotProduct、crossProduct、norm来计算点乘、叉乘、求模……

    注意:这里的myVector和C++里自带的库文件vector不同,这里只是含3个分量的空间矢量,而C++中的vector则更类似于一维变长度数组。

    矢量类 myVector的框架如下:

    成员变量

    1. 矢量在x方向的三个分量
    2. 矢量在y方向的三个分量
    3. 矢量在z方向的三个分量

    成员函数

    1. 构造函数1,由三个分量构造,缺省值为0
    2. 构造函数2,由另一个矢量构造,即,拷贝构造
    3. 析构函数,由于没有指针和动态释放空间,所以啥也不用做
    4. print函数,输出(x, y, z)
    5. 提取x,y,z分量的getX,getY,getZ函数
    6. 设置x,y,z分量的setX,setY,setZ函数
    7. 同时设置x,y,z分量的setVal函数,缺省值是0
    8. 赋值函数=,两个矢量间的赋值,即,拷贝赋值
    9. 操作符+:矢量+矢量,矢量+标量
    10. 操作符-:矢量-矢量,矢量-标量
    11. 操作符+=:矢量+=矢量,矢量+=标量
    12. 操作符-=:矢量-=矢量,矢量-=标量
    13. 操作符* :矢量 * 标量,标量 * 矢量
    14. 操作符/ :矢量 / 标量
    15. 操作符 *=:矢量 *= 标量
    16. 操作符 /=:矢量 /= 标量
    17. 点乘dotProduct:,完成两向量的点积
    18. 叉乘crossProduct:,完成两向量的叉积
    19. 输出流 <<:输出向量
    20. 幅值norm:计算向量幅值/二范数/模
    21. 单位化unit:向量除以其幅值

    写好的程序如下:

    myVector.h头文件

    // 2020-06-09
    // class myVector
    // definition and functions of a vector [x, y, z]
    // can be used for points, velocity, etc. in CFD
    #ifndef myVector_H
    #define myVector_H
    
    #include <iostream>
    
    class myVector
    {
    private:
    	double m_dX;	// component in x direction
    	double m_dY;	// .............y..........
    	double m_dZ;	// .............z..........
    
    public:
    	// construct with input x, y and z, default 0
    	myVector(double x = 0.0, double y = 0.0, double z = 0.0);
    	// construct with another myVector
    	myVector(const myVector &);			
    	
    	// destructor, do nothing
    	~myVector();
    
    	// print
    	void print() const;
    
    	// get x, y, z
    	double getX() const;
    	double getY() const;
    	double getZ() const;
    
    	// set x, y, z
    	void setX(double x = 0.0);
    	void setY(double y = 0.0);
    	void setZ(double z = 0.0);
    
    	// set total
    	void setVal(double x = 0.0, double y = 0.0, double z = 0.0);
    
    	// overload =
    	myVector & operator=(const myVector &);
    
    	// operator overload
    	// +: (x1, y1, z1) + (x2, y2, z2) = (x1 + x2, y1 + y2, z1 + z2)
    	friend myVector operator+(const myVector &, const myVector &);
    	// +: (x1, y1, z1) + b = (x1 + b, y1 + b, z1 + b)
    	friend myVector operator+(const myVector &, double);
    	
    	// -: (x1, y1, z1) - (x2, y2, z2) = (x1 - x2, y1 - y2, z1 - z2)
    	friend myVector operator-(const myVector &, const myVector &);
    	// -: (x1, y1, z1) - b = (x1 - b, y1 - b, z1 - b)
    	friend myVector operator-(const myVector &, double);
    
    	// +=: add another vector or a scalar
    	myVector & operator+=(const myVector &);
    	myVector & operator+=(double);
    
    	// -=: substract another vector or a scalar
    	myVector & operator-=(const myVector &);
    	myVector & operator-=(double);
    
    	// multiply
    	// *: (x1, y1, z1) * b = (x1 * b, y1 * b, z1 * b)
    	friend myVector operator*(const myVector &, double);
    	// *: b * (x1, y1, z1) = (x1, y1, z1) * b
    	friend myVector operator*(double, const myVector &);
    
    	// divide
    	// /: (x1, y1, z1) / b = (x1 / b, y1 / b, z1 / b)
    	friend myVector operator/(const myVector &, double);
    
    	// *=: multiply a scalar
    	myVector & operator*=(double);
    
    	// /=: divied by a scalar
    	myVector & operator/=(double);
    
    	// dot product
    	// (x1, y1, z1) dot (x2, y2, z2) = x1 * x2 + y1 * y2 + z1 * z2
    	friend double dotProduct(const myVector &, const myVector &);
    	
    	// cross product
    	// (x1, y1, z1) cross (x2, y2, z2) = 
    	//     |  i  j  k |
    	//     | x1 y1 z1 |
    	//     | x2 y2 z2 |
    	friend myVector crossProduct(const myVector &, const myVector &);
    
    	// output <<
    	friend std::ostream & operator<<(std::ostream &, const myVector &);
    
    	// magnitude
    	// norm([x, y, z]) = sqrt(x^2 + y^2 + z^2)
    	friend double norm(const myVector &);
    
    	// unit
    	// unit([x, y, z]) = [x, y, z] / norm([x, y, z])
    	friend myVector unit(const myVector &);
    };
    
    #endif
    

    myVector.cpp文件

    #include "myVector.h"
    
    // construct with input x, y and z, default 0
    myVector::myVector(double x, double y, double z)
    {
    	m_dX = x;
    	m_dY = y;
    	m_dZ = z;
    }
    
    // construct with another myVector
    myVector::myVector(const myVector & vct)
    {
    	m_dX = vct.m_dX;
    	m_dY = vct.m_dY;
    	m_dZ = vct.m_dZ;
    }
    
    // destructor, do nothing
    myVector::~myVector()
    {
    }
    
    // print
    void myVector::print() const
    {
    	std::cout <<
    		"(" << m_dX << ", " << m_dY << ", " << m_dZ << ")" << std::endl;
    }
    
    // get x, y, z
    double myVector::getX() const
    {
    	return m_dX;
    }
    
    double myVector::getY() const
    {
    	return m_dY;
    }
    
    double myVector::getZ() const
    {
    	return m_dZ;
    }
    
    // set x, y, z
    void myVector::setX(double x)
    {
    	m_dX = x;
    }
    
    void myVector::setY(double y)
    {
    	m_dY = y;
    }
    
    void myVector::setZ(double z)
    {
    	m_dZ = z;
    }
    
    // set total
    void myVector::setVal(double x, double y, double z)
    {
    	m_dX = x;
    	m_dY = y;
    	m_dZ = z;
    }
    
    // operator overload
    // =
    myVector & myVector::operator=(const myVector & vct)
    {
    	m_dX = vct.m_dX;
    	m_dY = vct.m_dY;
    	m_dZ = vct.m_dZ;
    	return *this;
    }
    
    // +: (x1, y1, z1) + (x2, y2, z2) = (x1 + x2, y1 + y2, z1 + z2)
    myVector operator+(const myVector & vct1, const myVector & vct2)
    {
    	myVector tmp(
    		vct1.m_dX + vct2.m_dX, vct1.m_dY + vct2.m_dY, vct1.m_dZ + vct2.m_dZ);
    	return tmp;
    }
    
    // +: (x1, y1, z1) + b = (x1 + b, y1 + b, z1 + b)
    myVector operator+(const myVector & vct1, double dbl)
    {
    	myVector tmp(
    		vct1.m_dX + dbl, vct1.m_dY + dbl, vct1.m_dZ + dbl);
    	return tmp;
    }
    
    // -: (x1, y1, z1) - (x2, y2, z2) = (x1 - x2, y1 - y2, z1 - z2)
    myVector operator-(const myVector & vct1, const myVector & vct2)
    {
    	myVector tmp(
    		vct1.m_dX - vct2.m_dX, vct1.m_dY - vct2.m_dY, vct1.m_dZ - vct2.m_dZ);
    	return tmp;
    }
    
    // -: (x1, y1, z1) - b = (x1 - b, y1 - b, z1 - b)
    myVector operator-(const myVector & vct1, double dbl)
    {
    	myVector tmp(
    		vct1.m_dX - dbl, vct1.m_dY - dbl, vct1.m_dZ - dbl);
    	return tmp;
    }
    
    // +=: add another vector
    myVector & myVector::operator+=(const myVector & vct)
    {
    	m_dX += vct.m_dX;
    	m_dY += vct.m_dY;
    	m_dZ += vct.m_dZ;
    	return *this;
    }
    
    // +=: add a scalar
    myVector & myVector::operator+=(double dbl)
    {
    	m_dX += dbl;
    	m_dY += dbl;
    	m_dZ += dbl;
    	return *this;
    }
    
    // -=: substract another vector
    myVector & myVector::operator-=(const myVector & vct)
    {
    	m_dX -= vct.m_dX;
    	m_dY -= vct.m_dY;
    	m_dZ -= vct.m_dZ;
    	return *this;
    }
    
    // -=: substract a scalar
    myVector & myVector::operator-=(double dbl)
    {
    	m_dX -= dbl;
    	m_dY -= dbl;
    	m_dZ -= dbl;
    	return *this;
    }
    
    // multiply
    // *: (x1, y1, z1) * b = (x1 * b, y1 * b, z1 * b)
    myVector operator*(const myVector & vct, double dbl)
    {
    	myVector tmp(vct.m_dX * dbl, vct.m_dY * dbl, vct.m_dZ * dbl);
    	return tmp;
    }
    // *: b * (x1, y1, z1) = (x1, y1, z1) * b
    myVector operator*(double dbl, const myVector & vct)
    {
    	return (vct * dbl);
    }
    
    // divide
    // /: (x1, y1, z1) / b = (x1 / b, y1 / b, z1 / b)
    myVector operator/(const myVector & vct, double dbl)
    {
    	// if dble equals 0, it will return INF
    	return (vct * (1.0 / dbl));
    }
    
    // *=: multiply a scalar
    myVector & myVector::operator*=(double dbl)
    {
    	m_dX *= dbl;
    	m_dY *= dbl;
    	m_dZ *= dbl;
    	return *this;
    }
    
    // /=: divied by a scalar
    myVector & myVector::operator/=(double dbl)
    {
    	m_dX /= dbl;
    	m_dY /= dbl;
    	m_dZ /= dbl;
    	return *this;
    }
    
    // dot product
    // (x1, y1, z1) dot (x2, y2, z2) = x1 * x2 + y1 * y2 + z1 * z2
    double dotProduct(const myVector & vct1, const myVector & vct2)
    {
    	return (vct1.m_dX * vct2.m_dX + vct1.m_dY * vct2.m_dY
    		+ vct1.m_dZ * vct2.m_dZ);
    }
    
    // cross product
    // (x1, y1, z1) cross (x2, y2, z2) = 
    // |  i  j  k |
    // | x1 y1 z1 |
    // | x2 y2 z2 |
    myVector crossProduct
    	(const myVector & vct1, const myVector & vct2)
    {
    	myVector tmp;
    	tmp.m_dX = vct1.m_dY * vct2.m_dZ - vct1.m_dZ * vct2.m_dY;
    	tmp.m_dY = vct1.m_dZ * vct2.m_dX - vct1.m_dX * vct2.m_dZ;
    	tmp.m_dZ = vct1.m_dX * vct2.m_dY - vct1.m_dY * vct2.m_dX;
    	return tmp;
    }
    
    // output stream <<
    std::ostream & operator<<(std::ostream & os, const myVector & vct)
    {
    	os << "(" << vct.m_dX << ", " << vct.m_dY << ", " << vct.m_dZ << ")";
    	return os;
    }
    
    // magnitude
    // norm([x, y, z]) = sqrt(x^2 + y^2 + z^2)
    double norm(const myVector & vct)
    {
    	return std::sqrt(
    		vct.m_dX * vct.m_dX + vct.m_dY * vct.m_dY + vct.m_dZ * vct.m_dZ);
    }
    
    // unit
    // unit([x, y, z]) = [x, y, z] / norm([x, y, z])
    myVector unit(const myVector & vct)
    {
    	return (vct / norm(vct));
    }
    

    测试主函数main.cpp

    // 2020-06-09
    // test class myVector
    #include <iostream>
    #include "myVector.h"
    
    using namespace std;
    
    int main()
    {
    	// test constructor with non input
    	myVector a;
    	// test print()
    	cout << "Test constructor with 0 input, and print(): " << endl;
    	cout << "After myVector a, a = ";
    	a.print();
    	cout << endl;
    	
    	// test constructor with 1, 2, 3 input
    	myVector b1(1.2);
    	myVector b2(1.2, 1.2);
    	myVector b3(1.2, 1.2, 1.2);
    	// test <<
    	cout << "Test constructor with 1, 2, 3 inputs, and << " << endl;
    	cout << "After myVector b1(1.2), b1 = " << b1 << endl;
    	cout << "After myVector b2(1.2, 1.2), b2 = "  << b2 << endl;
    	cout << "After myVector b3(1.2, 1.2, 1.2), b3 = "  << b3 << endl;
    	cout << endl;
    
    	// test setVal
    	myVector e;
    	cout << "Test setVal()" << endl;
    	e.setVal();
    	cout << "After e.setVal(), e: " << e << endl;
    	e.setX(1);
    	cout << "After e.setX(1), e: " << e << endl;
    	e.setY(2);
    	cout << "After e.setY(2), e: " << e << endl;
    	e.setZ(3);
    	cout << "After e.setZ(3), e: " << e << endl;
    	e.setVal(7, 8, 9);
    	cout << "After e.setVal(7, 8, 9), e: " << e << endl;
    	cout << endl;
    
    	// test
    	myVector c(2.3, 3.4, 5.6);
    	myVector d(5.6, 6.7, 7.8);
    	
    	// test operators
    	cout << "Test operators" << endl;
    	cout << "c:" << c << endl;
    	cout << "d:" << d << endl;
    
    	// test =
    	cout << "Test =" << endl;	
    	e = d;
    	cout << "After e = d, e =:" << e << endl;
    	
    	// test +
    	cout << "Test +" << endl;
    	cout << "d + c:" << d + c << endl;
    	cout << "d + 1:" << d + 1 << endl;
    
    	// test -
    	cout << "Test -" << endl;
    	cout << "d - c:" << d - c << endl;
    	cout << "d - 1:" << d - 1 << endl;
    	
    	// test *
    	cout << "Test *" << endl;
    	cout << "d * 2.0:" << d * 2.0 << endl;
    	cout << "2.0 * d:" << 2.0 * d << endl;
    
    	// test /
    	cout << "Test /" << endl;
    	cout << "d / 2.0:" << d / 2.0 << endl;
    	cout << "d / 0.0:" << d / 0.0 << endl;	
    
    	// test dotProduct
    	cout << "Test dotProduct" << endl;
    	cout << "dotProduct(d, c):" << dotProduct(d, c) << endl;
    
    	// test crossProduct
    	cout << "Test crossProduct" << endl;
    	cout << "crossProduct(d, c):" << crossProduct(d,c) << endl;
    
    	// test norm 2
    	cout << "Test norm" << endl;
    	cout  << "norm(d):" << norm(d) << endl;
    
    	// test unit
    	cout << "Test unit" << endl;
    	cout  << "unit(d):" << unit(d) << endl;
    
    	// test +=, -=
    	cout << "Test += vector/scalar, -= vector/scalar" << endl;
    	d += c;
    	cout << "After d += c, d = :" << d << endl;
    	d -= c;
    	cout << "After d -= c, d = :" << d << endl;
    	c += 2.0;
    	cout << "After c += 2.0, d = :" << c << endl;
    	c -= 2.0;
    	cout << "After c -= 2.0, d = :" << c << endl;
    
    	// test *=, /=
    	cout << "Test *= scalar, /= scalar" << endl;
    	d *= 2.0;
    	cout << "After d *= 2.0, d = :" << d << endl;
    	d /= 2.0;
    	cout << "After d /= 2.0, d = :" << d << endl;
    
    	return 0;
    }
    

    测试结果,表明所有函数均实现了其功能。
    在这里插入图片描述

    展开全文
  • C++ 实现向量

    千次阅读 2022-03-10 19:22:57
    使用 C++ 实现向量,并对其进行基本运算;

    使用 C++ 实现向量,并重载运算符 对其进行基本运算;

    将以下四个文件放入同一文件夹中,对 main.cpp 执行编译即可;

    本实现支持向量的两种表示:RECT(直角坐标表示)、POL(极坐标制),分别对应参数(x, y)、(mag,ang),其中 mag 为模长、ang为弧度(而非角度);

    PS:本实现基于《C++ Primer Plus》提供的方法并略有改动,评论区欢迎各位大佬提问、指正

    Vector.h

    #ifndef VECTOR_H_
    #define VECTOR_H_
    #include <iostream>
    using std::ostream;
    
    class Vector
    {
        public:
            enum Mode{RECT, POL};                                       // RECT for rectangular, POL for polar modes
        private:
            double x;
            double y;
            double mag;                                                 // length
            double ang;                                                 // direction in radian
            Mode mode;                                                  // RECT or POL
            void set_x_y();
            void set_mag_ang();
        public:
            Vector();                                                   // RECT mode is used by default
            Vector(double n1, double n2, Mode form = RECT);             // RECT mode is used by default
            void reset(double n1, double n2, Mode form = RECT);         // RECT mode is used by default
            void setmode(Mode form = RECT);                             // RECT mode is used by default
            // OPOL: operator overloading
            Vector operator+(const Vector &b) const;
            Vector operator-(const Vector &b) const;
            Vector operator-() const;
            Vector operator*(double n) const;
            Vector operator*(const Vector &b) const;
            friend Vector operator*(double n, const Vector &b);
            friend ostream &operator<<(ostream &os, const Vector &v);
    };
    
    #endif

     Vector.cpp

    #include <iostream>
    #include <cmath>
    #include "Vector.h"
    
    const double Rad_to_deg = 45.0 / atan(1.0);
    void Vector::set_x_y()
    {
        x = mag * cos(ang);
        y = mag * sin(ang);
    }
    void Vector::set_mag_ang()
    {
        mag = sqrt(x * x + y * y);
        if (x == 0.0 && y == 0.0)
            ang = 0.0;
        else
            ang = atan2(y, x);
    }
    Vector::Vector()
    {
        x = y = mag = ang = 0.0;
        mode = RECT;
    }
    Vector::Vector(double n1, double n2, Mode form)
    {
        if(form == POL)
        {
            mode = POL;
            mag = n1;
            ang = n2 / Rad_to_deg;
            set_x_y();
        }
        else
        {
            mode = RECT;
            x = n1;
            y = n2;
            set_mag_ang();
        }
    }
    void Vector::reset(double n1, double n2, Mode form)
    {
        if(form == POL)
        {
            mode = POL;
            mag = n1;
            ang = n2 / Rad_to_deg;
            set_x_y();
        }
        else
        {
            mode = RECT;
            x = n1;
            y = n2;
            set_mag_ang();
        }  
    }
    void Vector::setmode(Mode form)
    {
        if(form == POL)
            mode = POL;
        else
            mode = RECT;
    }

     OPOL.cpp

    // operator overloading
    #include <iostream>
    #include "Vector.h"
    using std::ostream;
    
    Vector Vector::operator+(const Vector &b) const
    {
        return Vector(x + b.x, y + b.y);
    }
    Vector Vector::operator-(const Vector &b) const
    {
        return Vector(x - b.x, y - b.y);
    }
    Vector Vector::operator-() const
    {
        return Vector(-x, -y);
    }
    Vector Vector::operator*(double n) const
    {
        return Vector(n * x, n * y);
    }
    Vector Vector::operator*(const Vector &b) const
    {
        return Vector(x * b.x, y * b.y);
    }
    Vector operator*(double n, const Vector &b)
    {
        return b * n;               // call the method in the class
    }
    ostream &operator<<(ostream &os, const Vector &v)
    {
        os << "(x, y) = (" << v.x << ", " << v.y << ")\n"
           << "mag = " << v.mag << "   ang = " << v.ang << "\n";
        return os;
    }

    main.cpp

    #include <iostream>
    #include "Vector.h"
    #include "Vector.cpp"
    #include "OPOL.cpp"
    using namespace std;
    
    int main()
    {
        Vector V1 = {};
        Vector V2 = {10.0, 37.0, Vector::POL};
    
        cout << "V1:" << endl;
        cout << V1;
        cout << "V2:" << endl;
        cout << V2;
        cout << "V1.reset(3.0, 4.0):" << endl;
        V1.reset(3.0, 4.0);
        cout << V1;
        cout << "V1 * 2:" << endl;
        cout << V1 * 2;
        cout << "V1 + V2:" << endl;
        cout << V1 + V2;
        cout << "V1 - V2:" << endl;
        cout << V1 - V2;
        cout << "V1 * V2:" << endl;
        cout << V1 * V2;
    
        while(true)
            cin.get();
        return 0;
    }

     

    展开全文
  • n维向量类(C++)

    2020-02-04 23:31:15
    写一个n维向量类,要求具有构造函数和拷贝构造函数,实现如下功能: a) 成员变量为正整数n和n维float数组 b) 能够计算该向量的模(长度),并将向量单位化 c) 进行向量的加减运算 d) 计算两个向量的内积
  • C++实现向量的旋转

    千次阅读 2017-11-01 15:29:53
    已知向量vector1[][]={{1},{1},{1}};,经过旋转之后得到的向量matrix_result[][]表示; 程序实现如下: #include "iostream" #include #include #include #include #include #include #include #include ...

    博记:通过输入旋转角度得到。

    已知向量vector1[][]={{1},{1},{1}};,经过旋转之后得到的向量matrix_result[][]表示;

    程序实现如下:

    #include "iostream"   
    #include<stdio.h>  
    #include<algorithm>  
    #include<string.h>  
    #include<math.h>  
    #include<stdlib.h>   
    #include<stack>  
    #include<vector> 
    #include<iomanip>
    using namespace std;
    const double pi=acos(-1.0);
    	#define SIZE_M 3    
        #define SIZE_N 3    
        #define SIZE_S 3    
        #define SIZE_T 3 
    
    #define J 1 
       int main()
       {
       double a;
       cout<<"a="<<endl;
       cin>>a;
       double b;
       cout<<"b="<<endl;
       cin>>b;
       double c;
       cout<<"c="<<endl;
       cin>>c;
       double r1[SIZE_M] [SIZE_N]={{1, 0, 0},{0, cos(a*pi), sin(a*pi)},{0, -sin(a*pi), cos(a*pi)}};//a矩阵3X3    
       double r2[SIZE_N] [SIZE_S]={{cos(b*pi), 0, -sin(b*pi)},{0, 1, 0},{sin(b*pi), 0, cos(b*pi)}};//b矩阵3X3   
       double r3[SIZE_S][SIZE_T]={{cos(c*pi), sin(c*pi), 0},{-sin(c*pi), cos(c*pi), 0},{0, 0, 1}};//c矩阵3*3  
       double vector1[SIZE_T][J]={{1},{1},{1}};
        double matrix_result[SIZE_M][SIZE_T];//旋转矩阵相乘之后的结果矩阵3*3  
    	double matrix_result1[SIZE_M][J];//旋转之后的向量
    
    	
       for(int m=0;m<SIZE_M;m++)  
        {    
            for(int j=0;j<J;j++)  
            {    
                matrix_result[m][j]=0;//变量使用前记得初始化,否则结果具有不确定性    
                for(int n=0;n<SIZE_N;n++)  
                {   
                    for(int s=0;s<SIZE_S;s++)  
                    {  
    					for(int t=0;t<SIZE_T;t++)
    					{
                        matrix_result[m][j]+=r1[m][n]*r2[n][s]*r3[s][t]*vector1[t][j]; 
    					}
                    }    
                }    
            }    
        }    
        for(int m=0;m<SIZE_M;m++)  
        {     
    		cout<<endl;
            for(int j=0;j<J;j++)  
            {  
    			cout<<left<<setw(20)<<matrix_result[m][j]<<setw(6);
                 //cout<<endl;  
            } 	
               
        } 
    
       system("pause");
       return 0;
       }
    运行结果:



    验证结果:



    展开全文
  • 本系列文章由birdlove1987编写。转载请注明出处。 文章链接:... 開始之前:接上上篇说的,张宇老师说过线性代数研究的就是向量。事实上严谨的说,数学中专门研究向量的分之称作线性...
  • 基于C++代码的UE4学习(一)—— ActorComponent与SceneComponent Actor是UE引擎中的一个类。类中可以包含很多类型的东西,这些东西可以是类的对象,也可以是组件的对象。 ActorComponent就是为Actor类添加更多...
  • (1)数组初始 Eigen::MatrixXd m(2,2); m(0,0)=1; m<<1,2,3,4; MatrixXd m=MatrixXd::Random(3,3); MatrixXd m1=MatrixXd::Constant(3,3,1.2); MatrixXd m2=Matrix2d::Zero(); //零初始 MatrixXd ...
  • c++ 空间向量类(Vector3D)的实现

    千次阅读 2021-08-11 13:05:15
    该类可用于描述3D向量和点在空间中的位置。 可以使用该类保存与计算 3D 位置和方向。 此外,它还包含用于执行常见向量操作的函数。 头文件: #pragma once #include <cmath> #include <iostream> using ...
  • c++计算两个三维向量之间的夹角

    千次阅读 2020-12-10 19:07:51
    结果返回 0 至 π 之间的计算结果,单位为弧度,在函数库中角度均以弧度来表示 //计算角度 Pnt3 p1p0 = p1p2[0].Co3d() - p0.Co3d(); Pnt3 p1p02 = p1p0.Normalize(); Pnt3 p2p0 = p1p2[1].Co3d() - p0....
  • 再来一个列向量类myVector。 其成员函数有两个,unsigned int类型的m_nSize存储元素数目,double类型的指针m_pdColVct用于动态申请和释放列向量的存储空间。 其构造函数可由元素数目和元素值(列向量中所有元素都是...
  • 向量归一即将向量的方向保持不变,大小归一到1。向量的归一化向量为: 引用 【1】...
  • 目录1. 数组到向量1. 数组2. 向量2. 接口3. 构造和析构4. 动态空间管理5. 常规向量6. 有序向量7....1. 数组到向量 数据结构按照逻辑次序的复杂程度可以分为线性...数组(array)是C++和Java里的一种内置的数据类型,从0...
  • OpenGL(C++):求两向量角平分线

    千次阅读 2020-11-16 19:42:36
    将OA⃗\vec{OA}OA和OB⃗\vec{OB}OB单位化,假设求得单位向量分别为:a⃗\vec{a}a和b⃗\vec{b}b。则a⃗\vec{a}a + b⃗\vec{b}b即为角平分线所在向量。 代码: 注意:函数最后返回的是角平分线所在向量,起点在中心点O...
  • Quant 是一个支持多种目标和单位类型的量化套件。 Quant 很小,只有标题,跨平台。 Quant 是公共领域。 特征 支持从/到有符号规范浮点数到/从 N 位短裤(d3d10 变体)的转换。 支持从/到有符号规范浮点数到/...
  • 根据3点求平面法向量c++

    千次阅读 2020-06-24 10:53:02
    //根据3点坐标求平面的单位向量(原点指向平面) void Use3PointsComputeNormalVector(vector p1, vector p2, vector p3,vector &NormalVector) {  //a = y1z2−y2z1  //b = z1x2−z2x1  //c =...
  • 场景空间和三维向量结构体FVector
  • 首先说一下自己的理解,然后参考理解 ...2、向量名代表这个容器的名字,&向量名表示这个容器的首地址 3、当拷贝给相同类型的其他变量时,采用值拷贝,即* 地址传值; 实例: 数组: 向量: 以下转自: ...
  • 「本文介绍了C++中Eigen库的代数运算模块和几何模块,以程序实例演示了常见指令用法。」Eigen是一个高层次开源C ++库,有效支持线性代数、矩阵和矢量运算、数值分析及其相关算法。在SLAM或者VIO研究中,对Eigen库的...
  • 4.1 矩阵和向量的初始 4.2 矩阵元素的赋值 4.3 矩阵元素的访问 4.4 获取矩阵大小 4.5 特殊矩阵的定义 4.5.1 全0矩阵 4.5.2 全1矩阵 4.5.3 矩阵置0 4.5.4 矩阵置1 4.5.5 随机矩阵 4.5.6 置为单位阵(不一定是方阵)...
  • 向量化执行引擎是怎么玩的?

    千次阅读 2022-02-25 11:22:33
    在比较前沿的数据库中,比如cilckhouse,polar-x,TDSQL,都提到了一个比较新的词汇,叫向量化执行引擎。 向量化执行引擎似乎已经成为了主流数据库执行器的唯一版本答案。 所以本篇博客来介绍数据库的向量...
  • cpp代码-写一个3D矢量类CVector3D,要求含三种构造函数,并有拷贝,点积,叉积,求模,单位化 等操作,并实现”+; -; =; ==; +=; -=; *; [ ]” 等运算符的重载。(用C++实现)
  •   设平面外一点为P(p1,p2,p3),指定的方向向量为d=(d1,d2,d3),平面Q方程为Ax+By+Cz=D,其法向量为n=(A,B,C)。则计算点P沿方向向量d到平面Q的距离,可以通过下式计算         (P+t* d)* n=D   [1]   ...
  • 目录前言符号约定向量的基本性质 【定义,基向量,线性相关/无关*,向量点积】矩阵的基本性质 【转置,广播,线性变换】矩阵基本运算 【矩阵相乘,矩阵点积】行列式 【概念,性质,右手法则,行列式计算】逆矩阵 ...
  • 第二章 C++数据结构 本章主要介绍了C++基本的数据结构,包括向量、列表、栈与队列、二叉树和图。主要的总结均来自于邓俊辉老师的《数据结构C++语言版》,在每一小节的背后,给出了一些在网上总结的面试题,以加强...
  • NX二次开发 数学方法获取两点向量 (C#/C++)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,817
精华内容 4,326
关键字:

c++向量单位化