精华内容
下载资源
问答
  • LinearInterpolators软件包为提供了许多线性插值方法。 从结果线性依赖于输入的意义上讲,这些插值是线性的。 特征 任何维数的数组都支持可分离的插值。 插值内核在每个插值维度上可以不同。 对于2D阵列,插值可以...
  • 多维区域中非线性偏微分方程的修正Laguerre谱与拟谱方法,徐承龙,郭本瑜,本文研究多维区域中非线性偏微分方程的谱与拟谱方法。我们建立了修正的Laguerre正交逼近与插值结果,这些结果对于建立和分析无界区�
  • 根据是用分段直线、多项式或样条函数来作为插值函数,插值问题又分为线性插值、多项式插值和样条插值等。 1.一维插值 如果被插值函数是一个单变量函数,则数据插值问题称为一维插值。一维插值采用的方法有线性方法、...

    MATLAB数据插值

    在工程测量和科学实验中,所得到的数据通常是离散的。
    如果要得到这些离散点以外的其他点的数值,就需要根据这些已知数据进行插值。
    根据被插值函数的自变量个数,插值问题分为一维插值、二维插值和多维插值等;根据是用分段直线、多项式或样条函数来作为插值函数,插值问题又分为线性插值、多项式插值和样条插值等。

    1.一维插值

    如果被插值函数是一个单变量函数,则数据插值问题称为一维插值。一维插值采用的方法有线性方法、最近方法、3次多项式和3次样条插值。

    函数interp1:插值函数
    Y1=interp1(X,Y,X1,method)
    根据X、Y的值,计算函数在X1处的值。其中,X、Y是两个等长的已知向量,分别描述采样点和采样值。若同一个采样点有多种采样值,则Y可以为矩阵,Y的每一列对应一组采样。X1是一个向量或标量,描述欲插值的点,Y1是一个与X1等长的插值结果。

    参数:method :用于指定插值方法,允许的取值有:
    ‘linear’:线性插值。线性插值是默认的插值方法,它是把与插值点靠近的两个数据点用直线连接,然后在直线上选取对应插值点的数据。
    ‘nearest’:最近点插值。根据插值点与已知数据点的远近程度进行插值。插值点优先选择较近的数据点进行插值操作。
    ‘pchip’:分段3次埃尔米特插值。MATLAB中有一个专门的3次Hermite插值函数pchip(X,Y,X1),其功能及使用方法与函数interp1(X,Y,X1,‘pchip’)相同。
    ‘spline’:3次样条插值。所谓3次样条插值,是指在每个分段(子区间)内构造一个3次多项式,使其插值函数除满足插值条件外,还要求在各节点处具有光滑的条件。MATLAB中有一个专门的3次样条插值函数spline(X,Y,X1),其功能及使用方法与函数interp1(X,Y,X1,‘spline’)相同。

    例:给出以下概率积分的数据表如表6-1所示,用不同的插值方法计算f(0.472)
    在这里插入图片描述

    >> x=0.46:0.01:0.49;         %给出x和f(x)
    >> f=[0.4846555,0.4937542,0.5027498,0.5116683];
    >> format long
    >> interp1(x,f,0.472)     %用默认方法,即线性插值计算f(0.472)
    ans =  0.495553320000000
    >> interp1(x,f,0.472,'nearest')  %用最近点插值计算f(0.472)
    ans = 0.493754200000000
    >> interp1(x,f,0.472,'pchip')      %用3次Hermite插值计算f(0.472)
    ans = 0.495561119712056
    >> interp1(x,f,0.472,'spline')    %用3次样条插值计算f(0.472)
    ans = 0.495560736000000
    format short
    

    例:某检测参数f随时间t的采样结果如表6-2,用数据插值法计算t=2,12,22,32,42,52时的f值
    在这里插入图片描述

    >> T=0:5:65;
    >> X=2:10:52;
    >>F=[3.2015,2.2560,879.5,1835.9,2968.8,4136.2,5237.9,6152.7,6725.3,6848.3,6403.5,6824.7,7328.5,7857.6];
    >> F1=interp1(T,F,X)        %用线性插值方法插值
    >> F2=interp1(T,F,X,'nearest')     %用最近点插值方法插值
    >> F3=interp1(T,F,X,'pchip')       %用3次Hermite插值方法插值
    >> F4=interp1(T,F,X,'spline')      %用3次样条插值方法插值
    

    2.二维插值

    当函数依赖于两个自变量变化时,其采样点就应该是一个由这两个参数组成的一个平面区域,插值函数也是一个二维函数。对依赖于两个参数的函数进行插值的问题称为二维插值问题。同样,在MATLAB中,提供了解决二维插值问题的函数interp2,其调用格式为:
    Z1=interp2(X,Y,Z,X1,Y1,method)
    其中,X、Y是两个向量,分别描述两个参数的采样点,Z是与参数采样点对应的函数值,X1、Y1是两个向量或标量,描述欲插值的点。Z1是根据相应的插值方法得到的插值结果。 method的取值与一维插值函数相同。X、Y、Z也可以是矩阵形式。

    例:设z=x2+y2,对z函数在[0,1]×[0,2]区域内进行插值。

    >> x=0:0.1:1;y=0:0.2:2;
    >> [X,Y]=meshgrid(x,y);       	%产生自变量网格坐标
    >> Z=X.^2+Y.^2;                	%求对应的函数值
    >> interp2(x,y,Z,0.5,0.5)     	%在(0.5,0.5)点插值
    ans =
        0.5100
    >> interp2(x,y,Z,[0.5 0.6],0.4) %在(0.5,0.4)点和(0.6,0.4)点插值
    ans =
        0.4100    0.5200
    >> interp2(x,y,Z,[0.5 0.6],[0.4 0.5])%在(0.5,0.4)点和(0.6,0.5)点插值
    ans =
        0.4100    0.6200
    %下一命令在(0.5,0.4),(0.6,0.4),(0.5,0.5)和(0.6,0.5)各点插值
    >> interp2(x,y,Z,[0.5 0.6]',[0.4 0.5])
    ans =
        0.4100    0.5200
        0.5100    0.6200
    

    3.曲线拟合的实现

    在MATLAB中,用polyfit函数来求得最小二乘拟合多项式的系数,再用polyval函数按所得的多项式计算所给出的点上的函数近似值。

    polyfit函数的调用格式为:
    P=polyfit(X,Y,m)
    [P,S]=polyfit(X,Y,m)
    [P,S,mu]=polyfit(X,Y,m)

    函数根据采样点X和采样点函数值Y,产生一个m次多项式P及其在采样点的误差向量S。其中,X、Y是两个等长的向量,P是一个长度为m+1的向量,P的元素为多项式系数。mu是一个二元向量,mu(1)是mean(X),而mu(2)是std(X)。可以用polyval函数按所得的多项式计算X各点上多项式的值。

    例:用一个3次多项式在区间[0,2π]内逼近函数。
    在给定区间上,均匀地选择50个采样点,并计算采样点的函数值,然后利用3次多项式逼近。

    >> X=linspace(0,2*pi,50);
    >> Y=sin(X);
    >> P=polyfit(X,Y,3)     %得到3次多项式的系数和误差
    P =
        0.0912   -0.8596    1.8527   -0.1649
    
    展开全文
  • 利用可耐高温高压、抗腐蚀、具有高屈服强度的钛金属作为传感器材料,采用组合式结构和特殊的圆膜片贴片与组桥技术,开发了适合于极端环境工作的钛压力传感器,并应用多维线性插值算法对传感器进行标定,以提高检测...
  • b样条插值matlab代码基础矩阵 该库的某些部分受到Paul Fackler和Mario Miranda的启发。 最初的Matlab代码是随出版物一起编写的 米兰达(Miranda),马里奥(Mario J.)和保罗·法克勒(Paul L.Fackler)。 应用计算...
  • 本资源是RBF网络的回归-非线性函数回归的实现的matlab仿真,RBF径向基函数是多维空间插值的传统技术。RBF神经网络结构简单、训练简洁而且学习收敛速度快,能够逼近任意非线性函数。
  • 当假设插值是分段线性时,这很容易。 但是,如果曲线是样条曲线,也许作为点之间的弦弧长的函数进行插值,这会变得有点困难。 一个很好的技巧是根据描述沿曲线路径的微分方程来表述问题。 然后可以使用 ODE 求解器...
  • 应用多维情形的二阶插值公式构造新型非线性滤波器。该滤波器不需非线性函数的偏导计算, 便能代替常规的扩展卡尔曼滤波器, 并有滤波精度高、 数值计算稳定和适用范围宽等优点。仿真实例表 明新滤波器具有较...
  • 其中提供了许多向量和矩阵操作,能让用户轻松完成最优化、线性代数、积分、插值、特殊函数、傅里叶变换、信号处理和图像处理、常微分方程求解以及其他科学与工程中常用的计算,不仅方便易用而且效率更高。...

    NumPy(Numerical Python)是 Python 语言的一个扩展程序库。其中提供了许多向量和矩阵操作,能让用户轻松完成最优化、线性代数、积分、插值、特殊函数、傅里叶变换、信号处理和图像处理、常微分方程求解以及其他科学与工程中常用的计算,不仅方便易用而且效率更高。
    NumPy 是一个开源的Python科学计算基础库,是SciPy、Pandas等数据处理或科学计算库的基础。拥有一个类似于列表的、强大的N维数组对象ndarray,它描述了相同类型的元素的集合。具有实用的线性代数、傅里叶变换和随机生成函数的功能。可以直接完成数组和矩阵运算,无需循环。

    1.创建一个数组,数组的shape为(5,2),元素均为0。

    import numpy
    data=[[0,0],[0,0],[0,0],[0,0],[0,0]]
    print(numpy.array(data))
    

    2.创建一个表示国际象棋棋盘的8*8数组。其中,棋盘白格用0填充,棋盘黑格用1填充。

    import matplotlib.pyplot as plt
    import numpy as np
    
    b1 = np.array([[(1),(0),(1),(0)]])#构建第一行的一半
    b2 = np.array([[(0),(1),(0),(1)]])#构建第二行的一半
    b3=np.vstack((b1,b2))#组合成可循环利用的部分
    b4=np.vstack((b3,b3))#构造出棋盘的1/4
    b5=np.hstack((b4,b4))#构造出棋盘的1/2
    b6=np.vstack((b5,b5))#构造出完整的棋盘
    plt.imshow(b6)
    plt.show()
    

    3.阅读下面文字和程序,理解numpy在线性代数运算中的运用。

    numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。
    numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。
    逆矩阵(inverse matrix):设A是数域上的一个n阶矩阵,若在相同数域上存在另一个n阶矩阵B,使得: AB=BA=E ,则我们称B是A的逆矩阵,而A则被称为可逆矩阵。注:E为单位矩阵。
    考虑以下线性方程:
    x + y + z = 6

    2y + 5z = -4

    2x + 5y - z = 27
    可以使用矩阵表示为:

    如果矩阵称为A、X和B,方程变为:
    AX = B

    X = A^(-1)B

    import numpy as np 
     
    a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 
     
    print ('数组 a:')
    print (a)
    ainv = np.linalg.inv(a) 
     
    print ('a 的逆:')
    print (ainv)
     
    print ('矩阵 b:')
    b = np.array([[6],[-4],[27]]) 
    print (b)
     
    print ('计算:A^(-1)B:')
    x = np.linalg.solve(a,b) 
    print (x)
    

    这就是线性方向 x = 5, y = 3, z = -2 的解

    import numpy as np
    
    a = np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]])
    
    print('数组 a:')
    print(a)
    ainv = np.linalg.inv(a)
    
    print('a 的逆:')
    print(ainv)
    
    print('矩阵 b:')
    b = np.array([[6], [-4], [27]])
    print(b)
    
    print('计算:A^(-1)B:')
    x = np.linalg.solve(a, b)
    print(x)
    

    请安装numpy包,并创建数组

    pycharm导入第三方库numpy

    import numpy
    

    numpy对象常用属性

    #numpy对象常用属性
    
    import numpy as np
    a=np.array([[1,2,3],[4,5,6]])
    print('a.ndim=',a.ndim)
    print(a)
    print(a.dtype)
    print(a.size)
    b=a.reshape(3,2)
    print(b.ndim)
    print(b)
    print(b.shape)
    print(b.itemsize)
    

    创建ndarry对象

    #创建ndarry对象
    
    import numpy as np
    a=np.array([1,2,3])
    print(a)
    b=np.array([[1,2],[3,4]])
    print(b)
    c=np.array([1,2,3,4,5],ndmin=2)
    print(c)
    d=np.array([1,2,3],dtype=complex)
    print(d)
    

    创建nmupy对象

    #创建nmupy对象
    
    import numpy as np
    x=np.zeros(5)
    print(x)
    y=np.zeros((5,),dtype=np.int)
    print(y)
    print()
    z=np.zeros((2,2),dtype=[('x','i4'),('y','i4')])
    print(z)
    

    从已有的数组来创建numpy数组

    #从已有的数组来创建numpy数组

    import numpy as np
    x=[1,2,3]
    a=np.asarray(x)
    print(a)
    print()
    y=[(1,2,3),(4,5)]
    b=np.asarray(y)
    print(b)
    

    从数值范围创建numpy数组

    #从数值范围创建numpy数组

    import numpy as np
    x=np.arange(10,21,2)
    print(x)
    
    y=np.linspace(10,20,5,endpoint=False)
    print(y)
    
    z=np.logspace(0,9,10,base=2)
    print(z)
    

    数组的运算

    #数组的运算

    import numpy as np
    a=np.array([1,2,3])
    b=np.array([3,4,5])
    print(a+b)
    print(a/b)
    print()
    
    c=np.array([[0],[1],[2],[3]])
    d=np.array([1,2,3])
    print(c)
    print()
    print(d)
    print()
    print(c+d)
    
    print(c*2)
    
    展开全文
  • 具有L2正则化的多维线性判别分析和Logistic回归 自然三次样条插值和留一法交叉验证 在高斯混合模型上使用期望最大化算法对USPS数字数据进行分类 使用多层感知器(神经网络)对USPS手写数字进行分类 k最近邻居分类 k...
  • 图卷积(1) 普通卷积神经网络 多维欧式空间 局部空间响应 卷积参数共享 活性卷积 一般卷积神经网络处理的...采用双线性插值法,在离散坐标下,通过插值方法计算得到连续位置的像素值。$$和$\beta$是可学习参数。但学

    图卷积(1)——从欧式空间到非欧式空间

    普通卷积神经网络

    1. 多维欧式空间
    2. 局部空间响应
    3. 卷积参数共享

    活性卷积

    一般卷积神经网络处理的数据都是规则排序,输入维度固定的,比如语音序列、图像像素或者视频帧,每一次卷积都是对每个处在规则空间内的数据进行聚合,并且聚合时的参数(卷积核)是一样的。当处于欧式空间内的数据发生了一些偏移,则可以采用活性卷积。


    双线性插值法

    采用双线性插值法,在离散坐标下,通过插值方法计算得到连续位置的像素值。 α\alphaβ\beta是可学习参数。但学习出来之后,可变卷积核的形状还是固定的。也就是说,在一个训练集上训练完后,α\alphaβ\beta便固定下来不会变,对所有的数据都是同样的α\alphaβ\beta

    可变卷积

    为了使卷积核的形状是数据驱动的,也就是说,遇到不同的数据时,卷积核的形状可自适应改变。这就是可变卷积(ICCV2017)
    可变卷积

    可变卷积

    卷积核位置参数化,由数据驱动的方式进行学习。蓝色的箭头表示偏移量,是个连续值,所以又实现了双线性插值连续化。
    3*3可变卷积操作

    3*3可变卷积操作

    网络结构如上图。先将输入特征图的一部分数据拿出来(绿色),进行卷积,得到每一个卷积核的偏移量。再对原来的特征图进行提取(蓝色),得到最终的结果。
    但是,在非欧式空间中,局部输入维度可变,排列无序。此时,卷积神经网络可能不太适合,需要图卷积来提取信息。

    图卷积

    图卷积一般分为谱域图卷积和空域图卷积:

    谱域图卷积:

    1. 根据图谱理论和卷积定理,将数据由空域转换到谱域做处理
    2. 有较为坚实的理论基础

    空域图卷积

    1. 不依靠图谱卷积理论,直接在空间上定义卷积操作
    2. 定义直观,灵活性更强
    展开全文
  • Unity3D - 详解Quaternion类

    万次阅读 2017-12-21 16:10:20
    一、简介 Quaternion又称四元数,由x,y,z和w这四个分量组成,是由爱尔兰数学家威廉·卢云·哈密顿在1843年发现的数学概念。...关于四元数的性质、与旋转的关系、球型线性插值的介绍,请阅读3D游戏与计算机

    一、简介

    Quaternion又称四元数,由x,y,z和w这四个分量组成,是由爱尔兰数学家威廉·卢云·哈密顿在1843年发现的数学概念。四元数的乘法不符合交换律。从明确地角度而言,四元数是复数的不可交换延伸。如把四元数的集合考虑成多维实数空间的话,四元数就代表着一个四维空间,相对于复数为二维空间。

    四元数

    关于四元数的性质、与旋转的关系、球型线性插值的介绍,请阅读3D游戏与计算机图形学中的数学方法-四元数,在此不多做介绍。下面主要介绍的是Unity中的四元数-Quaternion。

    在Unity中,用Quaternion来存储和表示对象的旋转角度。Quaternion的变换比较复杂,对于GameObject一般的旋转及移动,可以用Transform中的相关方法实现。

    二、Quaternion类属性

    eulerAngles-欧拉角

    定义

    public Vector3 eulerAngles{get;set;}

    如何改变一个游戏对象旋的转状态,我们可以通过改变其Transform进行欧拉角的变换次序,例如假设p(x,y,z)是游戏对象上的一个点,绕x轴旋转a角,绕y轴旋转b角,绕z轴旋转c角,这样就可以得到旋转之后的状态p'(x',y',z')。Unity的实现过程是很简单的,一句代码就可以搞定。但是具体的实现过程确实很复杂的,详情请阅读3D游戏与计算机图形学中的数学方法-变换

    下面给出一个例子,演示一下如何使用欧拉角。

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class EulerAngler_ts : MonoBehaviour {
        public Transform A, B;
        Quaternion rotations = Quaternion.identity;
        Vector3 eulerAngle = Vector3.zero;
        float speed = 10.0f;
        float tSpeed = 0.0f;
        // Use this for initialization
        void Start () {
    
        }
        
        // Update is called once per frame
        void Update () {
            tSpeed += speed * Time.deltaTime;
            //第一种方式:将Quaternion实例对象赋值给transform的rotation
            rotations.eulerAngles = new Vector3(0.0f, tSpeed, 0.0f);
            A.rotation = rotations;
            //第二种方式:将三位向量代表的欧拉角直接赋值给transform的eulerAngle
            B.eulerAngles = new Vector3(0.0f, tSpeed, 0.0f);
        }
    }
    复制代码

    三、Quaternion类实例方法

    1、SetFromToRotation方法-创建rotation实例

    1.1 函数原型

    public void SetFromToRotion(Vector3 fromDirection,Vector3 toDirection);

    可以创建一个从formDirection到toDirection的Quaternion实例。

    Quaternion q = Quaternion.identity;
    q.SetFromToRotation(v1,v2);
    transform.rotation = q;

    可以将GameObject对象进行如下变换:首先将GameObject对象自身坐标系的x,y,z轴方向和世界坐标系的x,y,z轴方向一致,然后将GameObject对象自身坐标系中向量V1指向的方向旋转到V2方向。

    1.2 PS:不可以直接使用transform.rotation.SetFromToRotation(v1,v2)方式进行设置,只能将实例化的Quaternion复制给transform.rotation。

    1.3 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class SetFromToDirection_ts : MonoBehaviour {
        public Transform A, B, C;
        Quaternion q = Quaternion.identity;
        // Use this for initialization
        void Start () {
        
        }
        
        // Update is called once per frame
        void Update () {
    
            q.SetFromToRotation(A.position, B.position);
            C.rotation = q;
            Debug.DrawLine(Vector3.zero, A.position, Color.red);
            Debug.DrawLine(Vector3.zero, B.position, Color.green);
            Debug.DrawLine(C.position, C.position + new Vector3(0.0f, 1.0f, 0.0f), Color.black);
            Debug.DrawLine(C.position, C.TransformPoint(Vector3.up * 1.5f), Color.yellow);
        }
    }
    复制代码

    运行结果如下图所示:

    2、SetLookRotation方法-设置Quaternion实例的朝向

    2.1 函数原型

    public void SetLookRotation(Vector3 view);
    public void SetLookRotation(Vector3 view,Vector3 up);

    例如:

    Quaternion q = Quaternion.identity;
    q.SetLookRotation(v1,v2);
    transform.rotation = q;

    transform.forward方向与V1方向相同。

    transform.right垂直于由Vector3.zer0、V1和V2这3点构成的平面。

    V2决定了transform.up的朝向,因为当transform.forward和transform.right方向确定后,transform.up的方向总会与V2的方向的夹角小于或等于90度。

    当V1为Vector3.zero时,方法失效。

    2.2 PS:同上,不要直接使用transform.rotation.SetLookRotation(v1,v2)的方式来实例化Quaternion对象。

    2.3 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class SetLookRotation_ts : MonoBehaviour {
    
        public Transform A, B, C;
        Quaternion q = Quaternion.identity;
        // Use this for initialization
        void Start()
        {
    
        }
    
        // Update is called once per frame
        void Update()
        {
    
            q.SetLookRotation(A.position, B.position);
            C.rotation = q;
            Debug.DrawLine(Vector3.zero, A.position, Color.red);
            Debug.DrawLine(Vector3.zero, B.position, Color.green);
            Debug.DrawLine(C.position, C.TransformPoint(Vector3.right * 1.5f), Color.black);
            Debug.DrawLine(C.position, C.TransformPoint(Vector3.forward * 1.5f), Color.yellow);
    
            Debug.Log("C.right与A的夹角: " + Vector3.Angle(C.right, A.position));
            Debug.Log("C.right与B的夹角: " + Vector3.Angle(C.right, B.position));
            Debug.Log("C.up与B的夹角: " + Vector3.Angle(C.up, B.position));
        }
    }
    复制代码

    运行结果

        

    3、ToAngleAxis方法

    3.1 函数原型

    public void ToAngleAxis(out float angle,out Vector3 axis);

    参数angle为旋转角,参数axis为轴向量。

    该函数可以实现将GameObject对象的rotation从Quaternion.identity状态变换到当前状态,只需要将GameObject对象绕着axis轴(世界坐标系)旋转angle角度即可。

    3.2 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class ToAngleAxis_ts : MonoBehaviour {
        public Transform A, B;
        float angle;
        Vector3 axis = Vector3.zero;
        float xSpeed = 0.0f, ySpeed = 0.0f, zSpeed = 0.0f;
        // Use this for initialization
        void Start () {
        
        }
        
        // Update is called once per frame
        void Update () {
            xSpeed += 0.5f * Time.deltaTime;
            ySpeed += 1.0f * Time.deltaTime;
            zSpeed += 2.5f * Time.deltaTime;
            A.eulerAngles = new Vector3(xSpeed, ySpeed, zSpeed);
            //获取A的rotation的旋转轴和角度
            A.rotation.ToAngleAxis(out angle, out axis);
            //设置B的rotation,使得B的rotation和A相同
            B.rotation = Quaternion.AngleAxis(angle, axis);
        }
    }

    四、Quaternion类静态方法

    Quaternion中的静态方法有9个即:Angle方法、Dot方法、Euler方法、FromToRotation方法、Inverse方法、Lerp方法、LookRotation方法、RotateToWards方法和Slerp方法。关于静态的方法的使用就是直接用类名调用其静态方法,例如Quaternion.Angle(q1,q2);下面对这些静态方法做下分析。

    1、Angle方法

    1.1 函数原型

    public static float Angle(Quaternion a,Quaternion b);

    该方法可以计算两个旋转状态a达到b时需要旋转的最小夹角。

    1.2 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class Angle_ts : MonoBehaviour {
       
    
        // Use this for initialization
        void Start () {
    
            Quaternion q1 = Quaternion.identity;
            Quaternion q2 = Quaternion.identity;
            q1.eulerAngles = new Vector3(30.0f, 40.0f, 50.0f);
            float a1 = Quaternion.Angle(q1, q2);
            float a2 = 0.0f;
            Vector3 v = Vector3.zero;
            q1.ToAngleAxis(out a2,out v);
    
            Debug.Log("a1: " + a1);
            Debug.Log("a2: " + a2);
            Debug.Log("q1的欧拉角: " + q1.eulerAngles + " q1的rotation: " + q1);
            Debug.Log("q2的欧拉角: " + q2.eulerAngles + " q2的rotation: " + q2);
        }
        
        // Update is called once per frame
        void Update () {
        
        }
    }
    复制代码

    运行结果

    从输出结果可以看出a1和a2的值相等,即Angle的返回值是两个Quaternion实例转换的最小夹角。

    2、Dot方法-点乘

    2.1 函数原型

    public static float Dot(Quaternion a,Quaternion b);

    该方法可以根据点乘的结果,判断a和b对应欧拉角的关系。

    例如有两个Quaternion实例q1(x1,y1,z1,w1)和q2(x2,y2,z2,w2),则float f = Quaternion.Dot(q1,q2);即f = x1*x2+y1*y2+z1*z2+w1*w2,结果值f的范围为[-1,1]。

    当f=+(-)1时,q1和q2对应的欧拉角是相等的,即旋转状态是一致的。特别地,当f = -1时,说明其中一个rotation比另外一个rotation多旋转了360°。

    2.2 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class Dot_ts : MonoBehaviour {
       
        public Transform A, B;
        Quaternion q1 = Quaternion.identity;
        Quaternion q2 = Quaternion.identity;
        // Use this for initialization
        void Start () {
    
            A.eulerAngles = new Vector3(0.0f, 40.0f, 0.0f);
            B.eulerAngles = new Vector3(0.0f, 360.0f + 40.0f, 0.0f);
            q1 = A.rotation;
            q2 = B.rotation;
            float f = Quaternion.Dot(q1, q2);
            
            Debug.Log("q1的欧拉角: " + q1.eulerAngles + " q1的rotation: " + q1);
            Debug.Log("q2的欧拉角: " + q2.eulerAngles + " q2的rotation: " + q2);
            Debug.Log("Dot(q1,q2): " + f);
        }
        
        // Update is called once per frame
        void Update () {
        
        }
    }
    复制代码

    运行输出

    从输出结果可以证明q1和q2的欧拉角相等,但是rotation值却是相反的,也说明当Dot的返回值为-1时,两个参数的角度相差360°。

    3、Euler方法

    3.1 函数原型

    public static Quaternion Euler(Vector3 euler);
    public static Quaternion Euler(float x,float y,float z);

    该方法用于返回欧拉角Vector3(ex,ey,ez)对应的四元数Quaternion q(qx,qy,qz,qw)。其对应关系如下:

    已知PIover180 = 3.141592/180 = 0.0174532925f是计算机图形学中的一个常亮,其变换过程如下:

    复制代码
    ex = ex * PIover180 / 2.0f;
    ey = ey * PIover180 / 2.0f;
    ez = ez * PIover180 / 2.0f;
    
    qx = Mathf.Sin(ex) * Mathf.Cos(ey) * Mathf.Cos(ez) + Mathf.Cos(ex) * Mathf.Sin(ey) * Mathf.Sin(ez);
    qy = Mathf.Cos(ex) * Mathf.Sin(ey) * Mathf.Cos(ez) - Mathf.Sin(ex) * Mathf.Cos(ey) * Mathf.Sin(ez);
    qz = Mathf.Cos(ex) * Mathf.Cos(ey) * Mathf.Sin(ez) - Mathf.Sin(ex) * Mathf.Sin(ey) * Mathf.Cos(ez);
    qw = Mathf.Cos(ex) * Mathf.Cos(ey) * Mathf.Cos(ez) + Mathf.Sin(ex) * Mathf.Sin(ey) * Mathf.Sin(ez);
    复制代码

    3.2 验证变换过程

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class Euler_ts : MonoBehaviour {
    
        public float ex, ey, ez;
        float qx, qy, qz,qw;
        float PIover180 = 0.0174532925f;
        Quaternion q = Quaternion.identity;
        Vector3 euler;
      
        void OnGUI()
        {
            if(GUI.Button(new Rect(10.0f,10.0f,100.0f,45.0f),"计算"))
            {
                euler = new Vector3(ex,ey,ez);
                Debug.Log("欧拉角Euler(ex,ey,ez): " + euler);
                q = Quaternion.Euler(ex, ey, ez);
                Debug.Log("对应的四元数为: " + q);
                Debug.Log("q.x: " + q.x + " q.y: " + q.y + " q.z: " + q.z + " q.w: " + q.w);
                //验证算法
                ex = ex * PIover180 / 2.0f;
                ey = ey * PIover180 / 2.0f;
                ez = ez * PIover180 / 2.0f;
    
                qx = Mathf.Sin(ex) * Mathf.Cos(ey) * Mathf.Cos(ez) + Mathf.Cos(ex) * Mathf.Sin(ey) * Mathf.Sin(ez);
                qy = Mathf.Cos(ex) * Mathf.Sin(ey) * Mathf.Cos(ez) - Mathf.Sin(ex) * Mathf.Cos(ey) * Mathf.Sin(ez);
                qz = Mathf.Cos(ex) * Mathf.Cos(ey) * Mathf.Sin(ez) - Mathf.Sin(ex) * Mathf.Sin(ey) * Mathf.Cos(ez);
                qw = Mathf.Cos(ex) * Mathf.Cos(ey) * Mathf.Cos(ez) + Mathf.Sin(ex) * Mathf.Sin(ey) * Mathf.Sin(ez);
                Debug.Log("qx: " + qx + " qy: " + qy + " qz: " + qz + " qw: " + qw);
            }
        }
    }
    复制代码

    运行结果

    从输出结果可以证明该公式是正确,另外转换后的四元数直接输出的话,如下:

     q = Quaternion.Euler(ex, ey, ez);
     Debug.Log("对应的四元数为: " + q);

    输出值是做了四舍五入处理的。

    4、FromToRotation方法

    函数原型

    public static Quaternion FromToRotation(Vector3 fromDirection,Vector3 ToDirection);

    在前面介绍了SetFromToRotation实例方法,它们的功能都是一样的只不过用法稍有不同。使用FromToRotation类静态方法,需要直接使用类名进行调用,如Quaternion.FromToRotation(v1,v2);

    在此就不做演示了!

    5、Inverse方法

    5.1 函数原型

    public static Quaternion Inverse(Quaternion rotation);

    该方法可以返回参数rotation的逆向Quaternion值。

    例如rotation(x,y,z,w),那么Quaternion.Inverse(rotation) = (-x,-y,-z,w)。假设rotation的欧拉角为(a,b,c),则transform.rotation = Quaternion.Inverse(rotation)相当于transform依次绕自身坐标系的z轴、x轴和y轴分别旋转-c°、-a°和-z°。由于是在局部坐标系内的变换,最后transform的欧拉角的各个分量值并不一定等于-a、-b或-c。

    5.2 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class Invers_ts : MonoBehaviour {
        public Transform A, B;
    
        // Use this for initialization
        void Start () {
    
            Quaternion q1 = Quaternion.identity;
            Quaternion q2 = Quaternion.identity;
            q1.eulerAngles = new Vector3(30.0f,40.0f,50.0f);
            q2 = Quaternion.Inverse(q1);
            A.rotation = q1;
            B.rotation = q2;
    
            Debug.Log("q1的欧拉角: " + q1.eulerAngles + "q1的rotation: " + q1);
            Debug.Log("q2的欧拉角: " + q2.eulerAngles + "q2的rotation: " + q2);
        }
        
        // Update is called once per frame
        void Update () {
        
        }
    }
    复制代码

    运行截图

    6、Lerp和Slerp方法

    6.1 函数原型

    public static Quaternion Lerp(Quaternion form, Quaternion to,float t);
    public static Quaternion Slerp(Quaternion form, Quaternion to,float t);

    两种方法的作用都是返回从form到to的插值。当参数t<=0时返回值为from,当参数t>=1时返回值为to。其中Lerp是线性差值,而Slerp是球面插值。

    6.2 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class LerpAndSlerp_ts : MonoBehaviour
    {
        public Transform A, B, C,D;
        float speed = 0.2f;
        float total = 0.0f;
        // Use this for initialization
        void Start () {
        
        }
        
        // Update is called once per frame
        void Update () {
            total += Time.deltaTime * speed;
            if(total >= 1.0f)
                total = 1.0f;
            C.rotation = Quaternion.Lerp(A.rotation, B.rotation, total);
            D.rotation = Quaternion.Lerp(A.rotation, B.rotation, total);
            //C.rotation = Quaternion.Lerp(A.rotation, B.rotation, Time.deltaTime * speed);
            //D.rotation = Quaternion.Lerp(A.rotation, B.rotation, Time.deltaTime * speed);
        }
    }
    复制代码

    7、RotateTowards方法

    7.1 函数原型

    public static Quaternion RotateTowards(Quaternion from, Quaternion to, float maxDegreesDelta);

    该方法也是一个插值方法,即从返回参数from到to的插值,且返回值的最大角度不超过maxDegreesDelta。maxDegreesDelta是角度值,不是插值系数,当maxDegreesDelta < 0时,将进行逆向插值即从to到from的方向进行插值计算。

    7.2 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class RotateToWards_ts : MonoBehaviour {
    
        public Transform A, B, C;
        float speed = 10.0f;
        float total = 0.0f;
        // Use this for initialization
        void Start()
        {
    
        }
    
        // Update is called once per frame
        void Update()
        {
            total += Time.deltaTime * speed;
            if (total >= 1.0f)
                total = 1.0f;
            C.rotation = Quaternion.RotateTowards(A.rotation, B.rotation, Time.time * speed - 40.0f);
            Debug.Log("C与A的欧拉角的插值: " + (C.eulerAngles - A.eulerAngles) + "maxDegreesDelta: " + (Time.time * speed - 40.0f));
    
        }
    }
    复制代码

    运行截图

    8、LookRotation方法

    函数原型

    public static Quaternion LookRotation(Vector3 forward);
    public static Quaternion LookRotation(Vector3 forward,Vector3 upwards);

    参数forward为返回Quaternion实例的forward朝向。该方法和前面讲到的SetLookRotation实例方法的功能是一样的,故不多做阐述了。

    五、Quaternion类运算符

    Quaternion类涉及到两个Quaternion对象相乘和Quaternion对象与Vector3对象相乘,那么就必须重载"*"运算符。

    1、函数原型

    public static Quaternion operator *(Quaternion lhs, Quaternion rhs);
    public static Vector3 operator *(Quaternion rotation, Vector3 point);

    2、两个Quaternion对象相乘

    对于两个Quaternion对象相乘主要用于自身旋转变换,例如:

    B.rotation *= A.rotation;
    • B会绕着B的局部坐标系的z、x、y轴按照先绕z轴再绕x轴最后绕y轴的旋转次序,分别旋转A.eulerAngles.z度、A.eulerAngles.x度、和A.eulerAngles.y度。由于是绕着局部坐标系进行旋转,所以当绕着其中一个轴进行旋转时,可能会影响其余两个坐标轴方向的欧拉角(除非其余两轴的欧拉角都为0才不会受到影响)。
    • 假如A的欧拉角为aEuler(ax,ay,az),则沿着B的初始局部坐标系的aEuler方向向下看B在绕着aEuler顺时针旋转。B的旋转状况还受到其初始状态的影响。

    2.1 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class Multiply1_ts : MonoBehaviour {
    
        public Transform A, B;
    
        // Use this for initialization
        void Start () {
    
            A.eulerAngles = new Vector3(1.0f, 1.5f, 2.0f);
        }
        
        // Update is called once per frame
        void Update () {
    
            B.rotation *= A.rotation;
            Debug.Log(B.eulerAngles);
        }
    }
    复制代码

    运行截图

    2.2 分析

    B绕着其自身坐标系的Vector3(1.0f,1.5f,2.0f)方向旋转。虽然每次都绕着这个轴向旋转的角度相同,但角度的旋转在3个坐标轴的值都不为零,三个轴的旋转会相互影响,所以B的欧拉角的各个分量的每次递增是不固定的。

    3、Quaternion对象与Vector3对象

    对于Quaternion对象与Vector3对象相乘主要用于自身移动变换,例如

    transform.position += tansform.rotation * A;

    其中A为Vector3的对象。transform对应的对象会沿着自身坐标系中向量A的方向移动A的模长的距离。transform.rotation与A相乘可以确定移动的方向和距离。

    3.1 实例演示

    复制代码
    using UnityEngine;
    using System.Collections;
    
    public class Multiply2_ts : MonoBehaviour {
        public Transform A;
        float speed = 0.1f;
    
        // Use this for initialization
        void Start () {
    
            A.position = Vector3.zero;
            A.eulerAngles = new Vector3(0.0f, 45.0f, 0.0f);
        }
        
        // Update is called once per frame
        void Update () {
    
            A.position += A.rotation * (Vector3.forward * speed);
            Debug.Log(A.position);
        }
    }
    复制代码

    运行截图

    4、两个Quaternion对象相乘与Quaternion对象与Vector3对象相乘的异同

    • 设A为两个两个Quaternion对象相乘的结果。B为Quaternion对象与Vector3对象相乘的结果。其中A为Quaternion类型,B为Vector3类型。
    • A与B的相同之处是它们都通过自身坐标系的“相乘”方式来实现在世界坐标系中的变换。
    • A主要用来实现transform绕自身坐标系的某个轴旋转,B主要用来实现transform沿着自身坐标系的某个方向移动。
    • 必须遵守Quaternion对象*Vector3对象的形式,不可以颠倒顺序。
    • 由于它们都是相对于自身坐标系进行的旋转或移动,所以当自身坐标系的轴向和世界坐标系的轴向不一致时,它们绕着自身坐标系中的某个轴向的变动都会影响到物体在世界坐标系中各个坐标轴的变动。

       四元数quaternion的变换比较复杂,但是在unity中已经给我们写好了相应的函数实现对transform的操作。

        在最近的一个项目中,遇到了一个单手指滑动手机屏幕实现对模型的一个旋转操作,在尝试了各种unity中的旋转函数之后都没能够达到想要的效果之后,我选择了用Quaternion.AngleAxis的函数来实现旋转的操作效果。

        首先我们来分析一下Quaternion.AngleAxis(angle,axis),参数angle和axis代表了物体的旋转角度和旋转轴心。如下图:红色箭头方向代表物体所围绕的旋转轴,旋转角度可以是自定义的。

        

        

        接下来,我们就要做两件事情,确定axis和计算angle。在这个项目中,我们是根据单个手指在手机屏幕上滑动,我们通过记录滑动的距离,X方向的增量,以及Y轴方向的增量来为后面计算axis和angle打下基础。unity的Input函数有GetTouch这个函数,我们只需要调用这个函数的相关方法就可以实现需求。

        现在,我们在unity中新建一个场景,在场景中新建一个立方块。

        

        注意立方块的世界坐标轴,Z轴的朝向应该是朝着摄像机的。根据之前对四元数脚本的分析,立方体的旋转脚本为:

        Gesture.cs:

      复制代码
       1 using UnityEngine;
       2 using System.Collections;
       3 
       4 public class gesture : MonoBehaviour {
       5     public Transform Cube;
       6     private float radius = 1080;
       7     private Vector3 originalDir = new Vector3(0f,0f,1080f);
       8     private Vector3 CenterPos = new Vector3(0, 0, 0);
       9     private Vector2 startPos;
      10     private Vector2 tempPos;
      11     private Vector3 tempVec;
      12     private Vector3 normalAxis;
      13     private float angle;
      14     // Use this for initialization
      15     void Start () {
      16         Cube = GameObject.Find("Cube").transform;
      17     }
      18     
      19     // Update is called once per frame
      20     void Update () {
      21         if (Input.touchCount == 1)
      22         {
      23             //Vector2 startPos = Input.compositionCursorPos;
      24             if (Input.GetTouch(0).phase == TouchPhase.Began)
      25             {
      26                 startPos = Input.GetTouch(0).position;
      27                 //tempPos = startPos;
      28             }
      29             //if (Input.GetTouch(0).phase == TouchPhase.Ended)
      30             //{
      31             //    tempPos = startPos;
      32             //}
      33             if (Input.GetTouch(0).phase == TouchPhase.Moved)
      34             {
      35                 tempPos = Event.current.mousePosition;
      36 
      37                 float tempX = tempPos.x - startPos.x;
      38                     
      39                 float tempY = tempPos.y - startPos.y;
      40 
      41                 //tempPos = Input.GetTouch(0).deltaPosition;
      42                 //float tempX = tempPos.x;
      43 
      44                 //float tempY = tempPos.y;
      45 
      46                 float tempZ = Mathf.Sqrt(radius * radius - tempX * tempX - tempY * tempY);
      47 
      48                 tempVec = new Vector3(tempX, tempY, tempZ);
      49 
      50                 angle = Mathf.Acos(Vector3.Dot(originalDir.normalized, tempVec.normalized)) * Mathf.Rad2Deg;
      51 
      52                 normalAxis = getNormal(CenterPos, originalDir, tempVec);
      53 
      54                 Cube.rotation = Quaternion.AngleAxis(2 *angle, normalAxis);
      55 
      56             }
      57         }
      58     }
      59 
      60     void OnGUI()
      61     {
      62         GUILayout.Label("StartPos 的坐标值为: "+startPos);
      63         GUILayout.Label("tempPos 的坐标值为: " + tempPos);
      64         GUILayout.Label("tempVec 的坐标值为: " + tempVec);
      65         GUILayout.Label("normalAxis 的坐标值为: " + normalAxis);
      66         GUILayout.Label("旋转角度的值为: " + 2*angle);
      67         GUILayout.Label("Cube的四元数角度: " + Cube.rotation);
      68         GUILayout.Label("Cube de rotation.x: " + Cube.rotation.eulerAngles.x);
      69         GUILayout.Label("Cube de rotation.y: " + Cube.rotation.eulerAngles.y);
      70         GUILayout.Label("Cube de rotation.z: " + Cube.rotation.eulerAngles.z);
      71     }
      72 
      73     private Vector3 getNormal(Vector3 p1,Vector3 p2,Vector3 p3)
      74     {
      75         float a = ((p2.y - p1.y) * (p3.z - p1.z) - (p2.z - p1.z) * (p3.y - p1.y));
      76 
      77         float b = ((p2.z - p1.z) * (p3.x - p1.x) - (p2.x - p1.x) * (p3.z - p1.z));
      78 
      79         float c = ((p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x));
      80         //a对应的屏幕的垂直方向,b对应的屏幕的水平方向。
      81         return new Vector3(a, -b, c);
      82     }
      83 }
      复制代码

        如果我们将这个在新机上运行,会发现在第一次手指滑动旋转是正常的,但是第二次就会有个跳动的过程。在这里我们需要注意一个问题,四元数函数Quaternion.AngleAxis是将立方体以初始的旋转角度来进行围绕着轴Axis旋转Angle角度,不是在上一个状态下的增量。如果需要延续上一次的旋转状态,就需要将这个物体的rotation恢复到初始的状态。按照这个思路,我在Cube添加了一个父对象,我们在操作的时候对这个父对象进行操作,然后手指在离开屏幕的时候,将Cube脱离父对象,然后将父对象的rotation进行还原,再将Cube绑定为父物体的子对象,在一下次手指旋转之后就会接着上一次的旋转状态进行旋转,实现了旋转的延续。

        

        实现的代码为:

      复制代码
       1 using UnityEngine;
       2 using System.Collections;
       3 
       4 public class gesture : MonoBehaviour {
       5     public Transform Cube;
       6     public Transform RotObj;
       7     private float radius = 1080;
       8     private Vector3 originalDir = new Vector3(0f,0f,1080f);
       9     private Vector3 CenterPos = new Vector3(0, 0, 0);
      10     private Vector2 startPos;
      11     private Vector2 tempPos;
      12     private Vector3 tempVec;
      13     private Vector3 normalAxis;
      14     private float angle;
      15     // Use this for initialization
      16     void Start () {
      17         Cube = GameObject.Find("Cube").transform;
      18     }
      19     
      20     // Update is called once per frame
      21     void Update () {
      22         if (Input.touchCount == 1)
      23         {
      24             //Vector2 startPos = Input.compositionCursorPos;
      25             if (Input.GetTouch(0).phase == TouchPhase.Began)
      26             {
      27                 startPos = Input.GetTouch(0).position;
      28             }
      29             if (Input.GetTouch(0).phase == TouchPhase.Moved)
      30             {
      31                 tempPos = Event.current.mousePosition;
      32 
      33                 float tempX = tempPos.x - startPos.x;
      34                     
      35                 float tempY = tempPos.y - startPos.y;
      36 
      37                 float tempZ = Mathf.Sqrt(radius * radius - tempX * tempX - tempY * tempY);
      38 
      39                 tempVec = new Vector3(tempX, tempY, tempZ);
      40 
      41                 angle = Mathf.Acos(Vector3.Dot(originalDir.normalized, tempVec.normalized)) * Mathf.Rad2Deg;
      42 
      43                 normalAxis = getNormal(CenterPos, originalDir, tempVec);
      44 
      45                 RotObj.rotation = Quaternion.AngleAxis(2 *angle, normalAxis);
      46 
      47             }
      48             if (Input.GetTouch(0).phase == TouchPhase.Ended)
      49             {
      50                 Cube.transform.parent = null;
      51                 RotObj.rotation = Quaternion.identity;
      52                 Cube.parent = RotObj;
      53             }
      54         }
      55     }
      56 
      57     void OnGUI()
      58     {
      59         GUILayout.Label("StartPos 的坐标值为: "+startPos);
      60         GUILayout.Label("tempPos 的坐标值为: " + tempPos);
      61         GUILayout.Label("tempVec 的坐标值为: " + tempVec);
      62         GUILayout.Label("normalAxis 的坐标值为: " + normalAxis);
      63         GUILayout.Label("旋转角度的值为: " + 2*angle);
      64         GUILayout.Label("Cube的四元数角度: " + Cube.rotation);
      65         GUILayout.Label("Cube de rotation.x: " + Cube.rotation.eulerAngles.x);
      66         GUILayout.Label("Cube de rotation.y: " + Cube.rotation.eulerAngles.y);
      67         GUILayout.Label("Cube de rotation.z: " + Cube.rotation.eulerAngles.z);
      68     }
      69 
      70     private Vector3 getNormal(Vector3 p1,Vector3 p2,Vector3 p3)
      71     {
      72         float a = ((p2.y - p1.y) * (p3.z - p1.z) - (p2.z - p1.z) * (p3.y - p1.y));
      73 
      74         float b = ((p2.z - p1.z) * (p3.x - p1.x) - (p2.x - p1.x) * (p3.z - p1.z));
      75 
      76         float c = ((p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x));
      77         //a对应的屏幕的垂直方向,b对应的屏幕的水平方向。
      78         return new Vector3(a, -b, c);
      79     }
      80 }
      复制代码

        现在对应着手指的滑动距离,然后调整参数radius,就可以实现比较顺滑的旋转效果,真机实现的效果就不展示了。

    展开全文
  • Unity中的四元数类详解【详解】

    千次阅读 2018-08-31 13:31:49
    一、简介 Quaternion又称四元数,由x,y,z和w这四个分量组成,是由爱尔兰数学家威廉·卢云·哈密顿在1843年发现的数学概念。...关于四元数的性质、与旋转的关系、球型线性插值的介绍,请阅读3D游戏与计算机图形学中...
  • Unity_四元素Quaternion

    2020-04-04 23:54:09
    一、简介 Quaternion又称四元数,由x,y,z和w这四个分量组成,是由爱尔兰数学家威廉·卢云·哈密顿在1843年发现的数学...关于四元数的性质、与旋转的关系、球型线性插值的介绍,请阅读3D游戏与计算机图形学中的数学方...
  • idx=find_idx(xi, xgrid) 该函数不仅与 HISTC 类似,还返回数据点在 binning 间隔内... 几个明显的应用示例: - 用于更复杂插值方案的分箱步骤,例如多维样条或线性张量插值。 - 生成具有给定概率分布的离散随机序列。
  • 一、简介 Quaternion又称四元数,由x,y,z和w这四个分量组成,是由爱尔兰数学家威廉·卢云·哈密顿在1843年发现的数学概念。...关于四元数的性质、与旋转的关系、球型线性插值的介绍,请阅读3D游戏与计算机图形学中...
  • scipy的功能 特殊函数 (scipy.special) ...插值 (scipy.interpolate) 傅立叶变换 (scipy.fftpack) 信号处理 (scipy.signal) 线性代数 (scipy.linalg) 稀疏特征值 (scipy.sparse) 统计 (scipy.stats) 多维图像处理...
  • 数学算法原书光盘

    2012-05-11 17:38:03
    7.多维快速傅里叶变换算法 第11章数据的统计描述 1.分布的矩——均值、平均差、标准差、方差、斜差和峰态 2.中位数的搜索 3.均值与方差的显著性检验 4.分布拟合的X平方检验 5.分布拟合的K-S检验法 第12章解常微分...
  • 对于大于三个的数据维度使用间接寻址,将多维索引转换为线性数组寻址,使该函数变慢。 该工具箱支持计算所有维度数据的 PDF、CDF 和幸存者函数,以及一维数据的逆 CDF (ICDF) 和累积风险函数。 该工具箱还支持网格...
  • scipy中的包及其作用

    千次阅读 2015-12-20 14:54:41
    scipy有多个子包组成子包名描述 ...interpolate插值和平滑样条函数 io输入和输出 linalg线性代数 ndimage多维图片处理 odr正交距离回归 optimize优化与根查找 signal信号处理 sparse稀疏矩阵与相关处理spatial空间
  • delphi算法集源码

    2012-07-24 09:46:04
    7.多维快速傅里叶变换算法 第11章数据的统计描述 1.分布的矩——均值、平均差、标准差、方差、斜差和峰态 2.中位数的搜索 3.均值与方差的显著性检验 4.分布拟合的X平方检验 5.分布拟合的K-S检验法 第12章解常...
  • 各种插值方法(线性、三次样条、谐波样条、Akima)。 各种插值实体(值、对数值、速率等)。 参数曲线,如 Nelson-Siegel 和 Nelson-Siegel-Svensson。 利率期限结构模型的模拟(具有局部和随机波动率的 LIBOR 市场...
  • 7.多维快速傅里叶变换算法 第11章数据的统计描述 1.分布的矩——均值、平均差、标准差、方差、斜差和峰态 2.中位数的搜索 3.均值与方差的显著性检验 4.分布拟合的X平方检验 5.分布拟合的K-S检验法 第12章解常微分...
  • Python数据分析常用库 Numpy, Scipy, Matplotlib, Pandas, Scikit-Learn, Keras, ...功能:最优化、线性代数、积分、插值、拟合、信号处理和图像处理、常微分方程求解等。 参考链接: http//www.scipy.org/ Matplotlib
  • 算法经典VC++数值分析

    热门讨论 2010-10-21 21:03:49
    12.7多维快速傅里叶变换算法 第13章 数据的统计描述 13.1分布的矩——均值、平均差、标准差、方差、斜差和峰态 13.2中位数的搜索 13.3均值与方差的显著性检验 13.4分布拟合的X2检验 13.5分布拟合的K-S检验法 ...
  • Visual C++ 常用数值算法集

    热门讨论 2012-03-19 11:57:59
    12.7多维快速傅里叶变换算法 第13章 数据的统计描述 13.1分布的矩——均值、平均差、标准差、方差、斜差和峰态 13.2中位数的搜索 13.3均值与方差的显著性检验 13.4分布拟合的X2检验 13.5分布拟合的K-S检验法 ...
  • 多维快速傅里叶变换算法第11章数据的统计描述1.分布的矩——均值、平均差、标准差、方差、斜差和峰态2.中位数的搜索3.均值与方差的显著性检验4.分布拟合的X平方检验5.分布拟合的K-S检验法第12章解常微分方程组1.定...
  • 《俄罗斯数学教材选译:数值方法(第5版)》视角新颖,内容翔实,阐述系统,主要内容包括:计算误差,插值与数值微分,数值积分,函数逼近,多维问题,数值代数方法,非线性方程组和最优化问题的解,常微分方程、偏...
  • 7.多维快速傅里叶变换算法 第11章数据的统计描述 1.分布的矩??均值、平均差、标准差、方差、斜差和峰态 2.中位数的搜索 3.均值与方差的显著性检验 4.分布拟合的X平方检验 5.分布拟合的K-S检验法 第12章解常...

空空如也

空空如也

1 2 3 4
收藏数 61
精华内容 24
关键字:

多维线性插值