精华内容
下载资源
问答
  • 向量的点乘与叉乘
    千次阅读
    2021-03-18 18:53:48

    1 点乘

    向量的点乘,也叫点积、内积、数量积。是指接受在实数 R R R 上的两个向量并返回一个实数值标量的二元运算。

    点积有两种定义方式:代数方式和几何方式。

    1.1 代数定义

    已知两个向量 a ⃗ = [ a 1 , a 2 , . . . , a n ] \vec a=[a_1,a_2,...,a_n] a =[a1,a2,...,an] b ⃗ = [ b 1 , b 2 , . . . , b n ] \vec b=[b_1,b_2,...,b_n] b =[b1,b2,...,bn],则向量 a ⃗ \vec a a 与向量 b ⃗ \vec b b 的内积代数定义

    a ⋅ b = a 1 b 1 + a 2 b 2 + . . . + a n b n a·b=a_1b_1+a_2b_2+...+a_nb_n ab=a1b1+a2b2+...+anbn

    即,对应元素相乘再相加。

    1.2 几何定义(只针对二维和三维空间)

    已知两个向量 a ⃗ = [ x 1 , y 1 , z 1 ] \vec a=[x_1,y_1,z_1] a =[x1,y1,z1] b ⃗ = [ x 2 , y 2 , z 2 ] \vec b=[x_2,y_2,z_2] b =[x2,y2,z2]|a||b| 分别为向量 a ⃗ \vec a a 与向量 b ⃗ \vec b b 的模, < a , b > = θ ∈ [ 0 , π ] <a,b>=θ∈[0,\pi] <a,b>=θ[0,π]为两向量夹角,则向量 a ⃗ \vec a a 与向量 b ⃗ \vec b b 的内积几何定义为:

    a ⋅ b = ∣ a ∣ ∣ b ∣ c o s θ a·b=|a||b|cosθ ab=abcosθ

    几何意义: 可以用来表示一个向量在另一个向量上的投影长度,为一个标量。

    2 叉乘

    向量的叉乘,也叫叉积、外积、向量积,是一种在向量空间中(也就是说向量元素个数为3)向量的二元运算。与点积不同,叉乘的运算结果是一个向量而不是一个标量,并且两个向量的叉积与这两个向量所构成的平面垂直。

    2.1 定义

    已知两个向量 a ⃗ = [ x 1 , y 1 , z 1 ] \vec a=[x_1,y_1,z_1] a =[x1,y1,z1] b ⃗ = [ x 2 , y 2 , z 2 ] \vec b=[x_2,y_2,z_2] b =[x2,y2,z2]|a||b| 分别为向量 a ⃗ \vec a a 与向量 b ⃗ \vec b b 的模, < a , b > = θ ∈ [ 0 , π ] <a,b>=θ∈[0,\pi] <a,b>=θ[0,π]为两向量夹角,则向量 a ⃗ \vec a a 与向量 b ⃗ \vec b b 的叉积定义为:

    模长: ∣ a × b ∣ = ∣ a ∣ ∣ b ∣ s i n θ |a×b|=|a||b|sinθ a×b=absinθ

    方向:两个向量的叉积与这两个向量所构成的平面垂直,且遵循右手准则(右手的四指从a以不超过180°的转角转向b时,竖起的大拇指指向是叉乘的方向。)

    2.2 坐标运算

    已知两个向量 a ⃗ = [ x 1 , y 1 , z 1 ] \vec a=[x_1,y_1,z_1] a =[x1,y1,z1] b ⃗ = [ x 2 , y 2 , z 2 ] \vec b=[x_2,y_2,z_2] b =[x2,y2,z2],则
    a ⃗ × b ⃗ = ∣ i j k x 1 y 1 z 1 x 2 y 2 z 2 ∣ \vec a×\vec b=\begin{vmatrix} i&j&k\\ x_1&y_1&z_1\\ x_2&y_2&z_2\\ \end{vmatrix} a ×b =ix1x2jy1y2kz1z2
    i 、 j 、 k i、j、k ijk 为XYZ三个轴的单位向量

    更多相关内容
  • 今天小编就为大家分享一篇pytorch点乘与叉乘示例讲解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 点乘与叉乘

    千次阅读 2021-12-28 14:34:27
    叉乘,又称向量的外积,运算结果为一个向量,该向量z向量a,b组成的平面垂直,计算公式如下: 向量叉乘得到是向量组成平面的法向量,法向量行列式的值可以解释为这两个向量a, b共起点时,所构成平行四边形的...

    0. 几何含义

    0.1 点乘

    点乘,又称向量的内积,结果为一个数,计算公式如下:

     上述公式的推导过程如下:

     因此,通过点乘可以得出两个向量之间的夹角,向量垂直时,点乘结果为0.

    0.2 叉乘

    叉乘,又称向量的外积,运算结果为一个向量,该向量z与向量a,b组成的平面垂直,计算公式如下:

     向量叉乘得到是向量组成平面的法向量,法向量行列式的值可以解释为这两个向量a, b共起点时,所构成平行四边形的面积。

    1. numpy实现

    1.1 向量点乘

    numpy中使用dot函数来完成向量之间的点乘(对应元素相乘再相加)

    1.2 矩阵点乘

    numpy中使用multiply函数来实现矩阵之间的点乘(对应位置元素相乘),也可使用 * 运算符实现相同的功能。此时两个矩阵的尺寸大小必须相等。

    1.3 矩阵叉乘

    numpy中使用matmul函数来实现矩阵之间的叉乘(对应位置元素相乘),也可使用 @ 运算符实现相同的功能。此时第一个矩阵的列数等于第二个矩阵的行数。

     总结:

    对于向量,使用dot函数完成向量的点乘

    对于矩阵,使用multiply函数和 * 运算符完成矩阵的点乘,使用matmul函数和@运算符完成矩阵的叉乘。

    2. pytorch实现

    2.1 矩阵点乘

    pytorch中使用mul函数来完成二维矩阵之间的点乘,同时 * 运算符也可实现相同的功能。

    >>> x
    tensor([[-0.9263,  0.3411, -0.0781, -0.9598],
            [-1.1215,  0.9547, -0.2663,  0.6355],
            [-0.2772,  0.2032, -1.4178, -1.8679]])
    >>> torch.ones([3, 4])
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    >>> y = torch.ones([3, 4]) 
    >>> x * y
    tensor([[-0.9263,  0.3411, -0.0781, -0.9598],
            [-1.1215,  0.9547, -0.2663,  0.6355],
            [-0.2772,  0.2032, -1.4178, -1.8679]])
    >>> torch.mul(x, y)
    tensor([[-0.9263,  0.3411, -0.0781, -0.9598],
            [-1.1215,  0.9547, -0.2663,  0.6355],
            [-0.2772,  0.2032, -1.4178, -1.8679]])

    2.2 矩阵叉乘

    pytorch中使用mm函数来完成二维矩阵之间的叉乘,同时@运算符【具体对应的函数应该是matmul】也可完成矩阵的叉乘

    pytorch中matmul函数是一个神奇的函数根据第一个和第二个输入tensor的维度得到的是不同的效果。具体介绍如下图所示:

    •  假设两个tensor都是一维向量,那么返回的结果是向量之间的点乘,即一个值
    • 假设两个tensor都是二维矩阵,那么返回的结果是矩阵的叉乘
    • 假设第一个tensor是一维向量,第二个tensor是二维矩阵,那么会给第一个tensor扩充一个维度,从而实现矩阵叉乘(一维向量的维度与二维矩阵的行数相等),得到结果之后将扩充的维度去除
    • 假设第一个tensor是二维矩阵,第二个tensor是一维向量,与上面类似,扩充维度之后进行矩阵叉乘,得到结果

    上述不同情形的具体过程可以用下图表示:

    此外,matmul函数实现了多维情况下矩阵的乘法,例如,输入的第一个tensor的维度为【k, m, p】,第二个tensor的维度为【k, p, n】,则最后的结果维度为【k,m,n】,即对于通道上的两个矩阵完成叉乘,然后组合在一起。

     3. matmul函数实现协方差batch计算

    协方差(Covariance)在概率论统计学中用于衡量两个变量的总体误差。而方差是协方差的一种特殊情况,即当两个变量是相同的情况。计算公式如下:

     对于矩阵

     根据协方差矩阵的定义: 协方差矩阵的每个元素是各个向量元素之间的协方差.可以得到对应的协方差矩阵求法如下:

    矩阵中的数据按行排列与按列排列求出的协方差矩阵是不同的,默认情况下按行排列。即每一行是一个observation(or sample),那么每一列就是一个随机变量。

     对应的协方差矩阵为:

     示例中,矩阵的维度为【m, n】表示m个样本,每个样本包含n个特征,最后得到的协方差矩阵维度为【n, n】。

    numpy中提供函数cov来协方差矩阵,具体用法如下:

    其中需要注意重要的参数rowvar的含义:

     使用cov函数来求协方差矩阵,默认情况下是按列排列,即每一行代表一个变量,而每一列代表一个sample(观测点)。即输入矩阵的维度【m,n】,输出的协方差矩阵维度【m,m】。

    >>> import torch 
    >>> x = torch.randn([3, 4]) 
    >>> x
    tensor([[-0.9263,  0.3411, -0.0781, -0.9598],
            [-1.1215,  0.9547, -0.2663,  0.6355],
            [-0.2772,  0.2032, -1.4178, -1.8679]])
    >>> np.cov(x.numpy())
    array([[ 0.41436621,  0.28581725,  0.2887559 ],
           [ 0.28581725,  0.87789806, -0.04488792],
           [ 0.2887559 , -0.04488792,  0.93183437]])

    当输入维度扩充到三维时,在numpy中需要利用for循环来遍历,然后组合,这样的时间效率较差,因此可以通过torch中提供的matmul函数来实现三维下的协方差矩阵求法。

    def cov_matrix(tensor, rowvar=True):
        # 输入为【batch, m个特征,n个样本】 输出【batch, m, m】
        tensor = tensor if rowvar else tensor.transpose(-1, -2)
        tensor = tensor - tensor.mean(dim=-1, keepdim=True)
        factor = 1/ (tensor.shape[-1] - 1)
        return factor * tensor @ tensor.transpose(-1, -2)

    参考链接

    向量和矩阵的点乘和叉乘_小白一直白-CSDN博客_矩阵的点乘和叉乘

    pytorch 中涉及到矩阵之间的乘法(torch.mul, *, torch.mm, torch.matmul, @)_厚积而薄发-CSDN博客_pytorch 矩阵内积

    增量计算海量数据协方差(pytorch)_daniaokuye的专栏-CSDN博客_pytorch 协方差

     Differentiable 1-D, 2-D covariance (numpy.cov) clone · Issue #19037 · pytorch/pytorch · GitHub

    展开全文
  • 点乘与叉乘是线性代数的基本知识,在工作中也经常能够遇到,下面我们来温习一下它们的概念以及使用C++代码对它们进行实现。


    点乘与叉乘是线性代数的基本知识,在工作中也经常能够遇到,下面我们来温习一下它们的概念以及使用C++代码对它们进行实现。

    1. 点乘

    • 概念

    向量的点乘,也叫点积、内积、数量积。是指在实数R上的两个向量的一种二元运算,这种运算返回一个实数值标量。点乘有两种定义方式:代数方式和几何方式。

    • 代数方式

    已知两个向量 a → = [ a 1 , a 2 , . . . , a n ] \overrightarrow{a} = [a_1, a_2,...,a_n] a =[a1,a2,...,an] b → = [ b 1 , b 2 , . . . , b n ] \overrightarrow{b} = [b_1, b_2,...,b_n] b =[b1,b2,...,bn],则向量 a → \overrightarrow{a} a 与向量 b → \overrightarrow{b} b 的内积代数定义为:
    a ⋅ b = a 1 b 1 + a 2 b 2 + . . . + a n b n a\cdot b=a_1b_1+a_2b_2+...+a_nb_n ab=a1b1+a2b2+...+anbn
    代数表示:对应元素相乘相加。

    • 几何定义(2维和3维)

    已知两个向量 a → = [ x 1 , y 1 , z 1 ] \overrightarrow{a} = [x_1,y_1,z_1] a =[x1,y1,z1] b → = [ x 2 , y 2 , z 2 ] \overrightarrow{b}=[x_2,y_2,z_2] b =[x2,y2,z2],它们的模值分别为 ∣ a ∣ |a| a ∣ b ∣ |b| b,它们的夹角为 θ ∈   [ 0 , π ] \theta \in \ [0,\pi] θ [0,π],那么向量 a → \overrightarrow{a} a 与向量 b → \overrightarrow{b} b 的几何定义为:
    a ⋅ b = ∣ a ∣ ∣ b ∣ c o s θ a\cdot b = |a||b|cos\theta ab=abcosθ
    几何意义: 可以用来表示一个向量在另一个向量上的投影长度,为一个标量。

    2. 叉乘

    向量的叉乘,也叫叉积、外积、向量积,是一种在向量空间中(也就是说向量元素个数为3)向量的二元运算。与点积不同,叉乘的运算结果是一个向量而不是一个标量,并且两个向量的叉积与这两个向量所构成的平面垂直。

    • 定义方式

    已知两个向量 a → = [ x 1 , y 1 , z 1 ] \overrightarrow{a} = [x_1,y_1,z_1] a =[x1,y1,z1] b → = [ x 2 , y 2 , z 2 ] \overrightarrow{b}=[x_2,y_2,z_2] b =[x2,y2,z2],它们的模值分别为 ∣ a ∣ |a| a ∣ b ∣ |b| b,它们的夹角为 θ ∈   [ 0 , π ] \theta \in \ [0,\pi] θ [0,π],那么向量 a → \overrightarrow{a} a 与向量 b → \overrightarrow{b} b 的叉乘表示为:

    • 模值 ∣ a × b ∣ = ∣ a ∣ ∣ b ∣ s i n θ |a × b | = ∣ a ∣ ∣ b ∣ s i n θ a×b=absinθ
    • 方向:两个向量的叉积与这两个向量所构成的平面垂直,且遵循右手准则(右手的四指从a以不超过180°的转角转向b时,竖起的大拇指指向是叉乘的方向。)

    在这里插入图片描述

    • 坐标运算

    假设: i 、 j 、 k i、j、k ijk分别为XYZ三个轴的单位向量,则叉乘运算表示如下:

    a → × b → = ∣ i j k x 1 y 1 z 1 x 2 y 2 z 2 ∣ = [ y 1 z 2 − y 2 z 1 , − ( x 1 z 2 − x 2 z 1 ) , x 1 y 2 − x 2 y 1 ] \overrightarrow{a}×\overrightarrow{b} = \begin{vmatrix} i& j& k\\ x_1& y_1& z_1 \\ x_2& y_2& z_2 \\ \end{vmatrix}=[y_1z_2-y_2z_1,-(x_1z_2-x_2z_1),x_1y_2-x_2y_1] a ×b =ix1x2jy1y2kz1z2=[y1z2y2z1,(x1z2x2z1),x1y2x2y1]

    特殊情况,如果a和b在平面XY上,那么Z=0,所以上面得到的值 ∣ x 1 y 2 − x 2 y 1 ∣ |x_1y_2 - x_2y_1| x1y2x2y1,方向朝Z轴。

    3. 代码实现

    根据对上面概念的理解,相信大家可以很快就能写出自己的点乘与叉乘函数操作,这里就不介绍了。在工作实际应用中,我们可能更多的使用Eigen对它们进行调用,Eigen可以很方便的实现点乘与叉乘操作,具体代码如下:

    #include <iostream>
    #include <Eigen/Dense>
     
    using namespace Eigen;
    using namespace std;
    int main()
    {
      Vector3d v(1,2,3);
      Vector3d w(0,1,2);
     
      cout << "Dot product: " << v.dot(w) << endl;//点乘
      double dp = v.adjoint()*w; //等同于点法
      cout << "Dot product via a matrix product: " << dp << endl;
      cout << "Cross product:\n" << v.cross(w) << endl;//叉乘
    }
    

    输出:
    在这里插入图片描述

    展开全文
  • 向量点乘与叉乘

    万次阅读 多人点赞 2019-02-25 14:06:01
    向量点乘与叉乘 向量(Vector)  在几乎所有的几何问题中,向量(有时也称矢量)是一个基本点。向量的定义包含方向和一个数(长度)。在二维空间中,一个向量可以用一对x和y来表示。例如由点(1,3)到(5,1的向量...

    向量点乘与叉乘

    向量(Vector)
          在几乎所有的几何问题中,向量(有时也称矢量)是一个基本点。向量的定义包含方向和一个数(长度)。在二维空间中,一个向量可以用一对x和y来表示。例如由点(1,3)到(5,1的向量可以用(4,-2)来表示。这里大家要特别注意,我这样说并不代表向量定义了起点和终点。向量仅仅定义方向和长度。

    向量加法
          向量也支持各种数学运算。最简单的就是加法。我们可以对两个向量相加,得到的仍然是一个向量。我们有:
          V1(x1, y1)+V2(x2, y2)=V3(x1+x2, y1+y2)
          下图表示了四个向量相加。注意就像普通的加法一样,相加的次序对结果没有影响(满足交换律),减法也是一样的。
     
    点乘(Dot Product)
          如果说加法是凭直觉就可以知道的,另外还有一些运算就不是那么明显的,比如点乘和叉乘。
          点乘比较简单,是相应元素的乘积的和:
          V1( x1, y1)   V2(x2, y2) = x1*x2 + y1*y2
          注意结果不是一个向量,而是一个标量(Scalar)。点乘有什么用呢,我们有:
          A   B = |A||B|Cos(θ)
          θ是向量A和向量B见的夹角。这里|A|我们称为向量A的模(norm),也就是A的长度, 在二维空间中就是|A| = sqrt(x2+y2)。这样我们就和容易计算两条线的夹角:    Cos(θ) = AB /(|A||B|)

          当然你知道要用一下反余弦函数acos()啦。(回忆一下cos(90)=0 和cos(0) = 1还是有好处的,希望你没有忘记。)这可以告诉我们如果点乘的结果,简称点积,为0的话就表示这两个向量垂直。当两向量平行时,点积有最大值
          另外,点乘运算不仅限于2维空间,他可以推广到任意维空间。(译注:不少人对量子力学中的高维空间无法理解,其实如果你不要试图在视觉上想象高维空间,而仅仅把它看成三维空间在数学上的推广,那么就好理解了)

    叉乘(cross product)
          相对于点乘,叉乘可能更有用吧。2维空间中的叉乘是:
          V1(x1, y1) X V2(x2, y2) = x1y2 – y1x2
          看起来像个标量,事实上叉乘的结果是个向量,方向在z轴上。上述结果是它的模。在二维空间里,让我们暂时忽略它的方向,将结果看成一个向量,那么这个结果类似于上述的点积,我们有:
        A x B = |A||B|Sin(θ)

          然而角度 θ和上面点乘的角度有一点点不同,他是有正负的,是指从A到B的角度。因此 ,向量的外积不遵守乘法交换率,因为向量a×向量b=-向量b×向量a在物理学中,已知力与力臂求外积,就是向量的外积,即叉乘。

          向量c的方向与a,b所在的平面垂直,且方向要用“右手法则”判断。判断方法如下:

    1.右手手掌张开,四指并拢,大拇指垂直于四指指向的方向;

    2.伸出右手,四指弯曲,四指与A旋转到B方向一致,那么大拇指指向为C向量的方向。

                                            

          另外还有一个有用的特征那就是叉积的绝对值就是A和B为两边说形成的平行四边形的面积。也就是AB所包围三角形面积的两倍。在计算面积时,我们要经常用到叉积。

    (译注:三维及以上的叉乘参看维基:http://en.wikipedia.org/wiki/Cross_product)

    点-线距离
          找出一个点和一条线间的距离是经常遇见的几何问题之一。假设给出三个点,A,B和C,你想找出点C到点A、B定出的直线间距离。第一步是找出A到B的向量AB和A到C的向量AC,现在我们用该两向量的叉积除以|AB|,这就是我们要找的的距离了(下图中的红线)。
        d = (AB x AC)/|AB| 

          如果你有基础的高中几何知识,你就知道原因了。上一节我们知道(AB X AC)/2是三角形ABC的面积,这个三角形的底是|AB|,高就是C到AB的距离。有时叉积得到的是一个负值,这种情况下距离就是上述结果的绝对值。
          当我们要找点到线段的距离时,情况变得稍稍复杂一些。这时线段与点的最短距离可能是点到线段的某一端点,而不是点到直线的垂线。例如上图中点C到线段AB的最短距离应该是线段BC。我们有集中不同的方法来判断这种特殊情况。第一种情况是计算点积AB B来判定两线段间夹角。如果点积大于等于零,那么表示AB到BC是在-90到90度间,也就是说C到AB的垂线在AB外,那么AB上到C距离最近的点就是B。同样,如果BAAC大于等于零,那么点A就是距离C最近的点。如果两者均小于零,那么距离最近的点就在线段AB中的莫一点。

    源代码参考如下:
         //Compute the dot product AB   BC
         int dot(int[] A, int[] B, int[] C){
             AB = new int[2];
             BC = new int[2];
             AB[0] = B[0]-A[0];
             AB[1] = B[1]-A[1];
             BC[0] = C[0]-B[0];
             BC[1] = C[1]-B[1];
             int dot = AB[0] * BC[0] + AB[1] * BC[1];
             return dot;
         }
         //Compute the cross product AB x AC
         int cross(int[] A, int[] B, int[] C){
             AB = new int[2];
             AC = new int[2];
             AB[0] = B[0]-A[0];
             AB[1] = B[1]-A[1];
             AC[0] = C[0]-A[0];
             AC[1] = C[1]-A[1];
             int cross = AB[0] * AC[1] - AB[1] * AC[0];
             return cross;
         }
         //Compute the distance from A to B
         double distance(int[] A, int[] B){
             int d1 = A[0] - B[0];
             int d2 = A[1] - B[1];
             return sqrt(d1*d1+d2*d2);
         }
         //Compute the distance from AB to C
         //if isSegment is true, AB is a segment, not a line.
         double linePointDist(int[] A, int[] B, int[] C, boolean isSegment){
             double dist = cross(A,B,C) / distance(A,B);
             if(isSegment){
                 int dot1 = dot(A,B,C);
                 if(dot1 > 0)return distance(B,C);
                 int dot2 = dot(B,A,C);
                 if(dot2 > 0)return distance(A,C);
             }
             return abs(dist);
         }

          上面的代码看起来似乎是很繁琐。不过我们可以看看在C++和C#中,采用了运算符重载的类point,用‘*’代表点乘,用'^'代表叉乘(当然'+''-'还是你所希望的),那么看起来就简单些,代码如下:

       //Compute the distance from AB to C
         //if isSegment is true, AB is a segment, not a line.
         double linePointDist(point A, point B, point C, bool isSegment){
             double dist = ((B-A)^(C-A)) / sqrt((B-A)*(B-A));
             if(isSegment){
                 int dot1 = (C-B)*(B-A);
                 if(dot1 > 0)return sqrt((B-C)*(B-C));
                 int dot2 = (C-A)*(A-B);
                 if(dot2 > 0)return sqrt((A-C)*(A-C));
             }
             return abs(dist);
         }

    展开全文
  • pytorch点乘与叉乘

    万次阅读 2019-03-23 10:50:11
    点乘 import torch x = torch.tensor([[3,3],[3,3]]) y = x*x #x.dot(x) z = torch.mul(x,x) #x.mul(x) print(y) print(z) 叉乘 import torch x = torch.tensor([[3,3],[3,3]]) y = torch.mm(x,x) #x.mm(x) print(y...
  • 矩阵和向量的点乘与叉乘

    千次阅读 2021-04-15 10:30:13
    矩阵和向量的点乘与叉乘、哈达玛积、Point-wise Product、Element-wise Multiplication
  • 一、点乘 点乘就是对应位置元素相乘(element-wise),可以通过*和torch.mul()函数实现,在神经网络模型中的符号为: 1.1 标量的点乘 示例: a = torch.randint(10,(3,3)) print(a) print(a*2) print(a.mul(a)) 输出...
  • 1.矩阵乘法dot函数矩阵的乘法就是矩阵a的第一行乘以矩阵b的第一列,各个元素对应相乘然后求和作为第一元素的值。矩阵只有当左边矩阵的列数等于右边矩阵的行数时,它们才可以相乘,乘积矩阵的行数等于左边矩阵的行数,...
  • 向量的点乘与叉乘应用

    千次阅读 2021-01-13 19:27:25
    还是不对的,所以我觉得叉乘求出的角度不能直接拿来用,反而点乘和Angle方法算出的夹角是对的,但是得不到负的角度。 总结:这里验证的时候,为了直观的观察,向量a用了特殊向量,是在坐标轴上的向量,这里也推导了...
  • 向量的点乘与叉乘的几何意义  很惭愧,作为一名学生,向量的最基本的知识全忘了,在最近做计算机图形学实验时,需要用到向量计算时,发现自己寸步难行。只好赶快百度”预习”一下。 向量的点乘:a * b 公式:a * ...
  • 矩阵点乘与叉乘的操作,python实现

    千次阅读 2022-04-21 18:52:24
    1. 线性代数中的矩阵乘法定义相同:np.dot() np.dot(A, B):对于二维矩阵,计算真正意义上的矩阵乘积,即A的i行元素B的j列元素相乘的积的和作为新矩阵的(i, j)元素;对于一维矩阵(即向量),计算两向量的内积。 ...
  • 原文https://blog.csdn.net/hc14519/article/details/50716299 其实这篇文章主要讨论为何向量叉积这样定义,标题是为了吸引人,让更多有同样疑惑的人搜到。 记得上大学时的第一节课是《空间解析几何...
  • 原文 这里简单做些关于二维向量的笔记 点乘 $V_1(x_1,y_1) V_2(x_2,y_2) = x_1*x_2+y_1*y_2$ 点乘是各项元素乘积的和,结果是一个标量而不是向量 点乘还有如下等式 ...叉乘(重头戏来了) $V_1(x_1...
  • 点乘叉乘运算法则

    千次阅读 2021-04-22 11:08:30
    点乘,也叫向量的内积、数量积。运算法则为向量a·向量...向量a·向量b=|a||b|cos在物理学中,已知力位移求功,其实便是求向量F向量s的内积,即要用点乘叉乘叉乘,也叫向量的外积、向量积。顾名思义,求下来的...
  • 数学:点乘与叉乘

    2018-12-20 14:08:00
    点乘 公式 几何意义 可用余弦定理推导 叉乘 公式 几何意义 三维上,是垂直于ab向量的法向量。 二维上,是ab向量所围成的平行四边形面积,即absinθ。 转载于:...
  • 其中 表示的是向量a的模即长度,为向量a向量b形成的夹角 2、点乘的矩阵表示: == 3、在游戏中的运用 (1) 计算两个向量之间的夹角,如下: = ===,得出为45度 在coocoscreator中,会已知一个向量和角度...
  • Math:向量的点乘与叉乘

    千次阅读 2019-08-07 00:57:57
    向量的内积(点乘:⋅\cdot⋅) 向量的内积又称为点乘,设两个向量为a,b∈R3a,b\in R^3a,b∈R3 ,则这两个向量的点乘结果为:对应分量的乘积和,计算结果为一个数值。如下为两向量的点乘的计算过程: a⋅b=aTb=∑i...
  • 今天豁然开朗来记录一下我理解的矩阵以及四元数和点乘与叉乘的理解。 首先说矩阵以及四元数 矩阵的乘法是根据n*m列来获取的,n的行数是代表结果的行数,m的列数代表结果的列数。 红色黑色表示第一个矩阵中...
  • 点乘:两个矩阵对应位置的元素相乘,且这两个矩阵行数列数相等 import numpy as np a=np.array([[1,2,3],[1,2,3],[1,2,3]]) b=np.array([[1,2,3],[1,2,3],[1,2,3]]) print(a*b) print(np.multiply(a,b)) [[1 4 9] [1...
  • 【Unity】向量点乘与叉乘

    千次阅读 2017-11-20 19:17:29
    【参考原文】Unity3D之Vector3.Dot和Vector3.Cross的使用 【参考原文】Unity3D之点乘和差乘  在Unity3D中,Vector3.Dot表示求两个向量的点积;... 简单的说,点乘判断角度,叉乘判断方向。 形象的说当一个敌
  • 向量的点乘:a*b公式:a*b= |a| * |b| * cosθ点乘又叫向量的内积、数量积...向量的叉乘:a∧ba∧b= |a| * |b| * sinθ向量积被定义为:模长:(在这里θ表示两向量之间的夹角(共起点的前提下)(0° ≤ θ ≤ 180°),...
  • 向量和矩阵的点乘叉乘

    千次阅读 2021-01-29 10:40:23
    向量 定义:向量是由N个实数组成的一...叉乘:又叫向量积、外积、叉积,叉乘,向量a[x1,y1,z1]和向量b[x2,y2,z2]叉乘的运算结果是一个向量,并且两个向量的叉积这两个向量组成的坐标平面垂直,记作axb; 计算方式:.
  • Unity中点乘和叉乘点乘(API: Vector3.Dot())点乘的计算公式点乘的几何意义用途之一:判断一个物体当前方位利用点乘求出角度叉乘(API: Vector3.Cross())叉乘计算公式叉乘的几何意义判断物体是在左侧还是右侧 点乘...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,903
精华内容 2,361
关键字:

点乘与叉乘

友情链接: hardware-timer.zip