最小二乘解与极小范数解算法的C++实现（支持复系数方程组）

最新推荐文章于 2023-12-14 17:26:22 发布
最新推荐文章于 2023-12-14 17:26:22 发布
阅读量862 收藏 3
点赞数
文章标签： c/c++ 操作系统 python
原文链接：https://my.oschina.net/zmjerry/blog/6185
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

头文件：

/*
 * Copyright (c) 2008-2011 Zhang Ming (M. Zhang), zmjerry@163.com
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 2 or any later version.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. A copy of the GNU General Public License is available at:
 * http://www.fsf.org/licensing/licenses
 */


/*****************************************************************************
 *                                linequs2.h
 *
 * Function template for solving linear equations.
 *
 * For a m-by-n (m!=n) coefficient matrix A and m-by-1 constant vector b, if
 * m>n, the exact solution of Ax=b is not existent, but we can find the least
 * square solution that minimize norm of Ax-b; if m<n, there are infinite
 * many solutions, but we can find the minimum norm sulution that minimize
 * norm of x.
 *
 * These functions, except QR domposition based methods, in this file can be
 * used by both REAL or COMPLEX linear equations.
 *
 * Zhang Ming, 2010-07 (revised 2010-12), Xi'an Jiaotong University.
 *****************************************************************************/


#ifndef UNDETLINEQUS_H
#define UNDETLINEQUS_H


#include <qrd.h>
#include <svd.h>
#include <cqrd.h>
#include <csvd.h>
#include <linequs1.h>


namespace splab
{

	template<typename Type>
	Vector<Type> lsSolver( const Matrix<Type>&, const Vector<Type>& );
	template<typename Real>
	Vector<Real> qrLsSolver( const Matrix<Real>&, const Vector<Real>& );
	template<typename Real>
	Vector<Real> svdLsSolver( const Matrix<Real>&, const Vector<Real>& );
	template<typename Type>
	Vector<complex<Type> > qrLsSolver( const Matrix<complex<Type> >&,
                                       const Vector<complex<Type> >& );
	template<typename Type>
	Vector<complex<Type> > svdLsSolver( const Matrix<complex<Type> >&,
                                        const Vector<complex<Type> >& );

	template<typename Type>
	Vector<Type> lnSolver( const Matrix<Type>&, const Vector<Type>& );
	template<typename Real>
	Vector<Real> qrLnSolver( const Matrix<Real>&, const Vector<Real>& );
	template<typename Real>
	Vector<Real> svdLnSolver( const Matrix<Real>&, const Vector<Real>& );
	template<typename Type>
	Vector<complex<Type> > qrLnSolver( const Matrix<complex<Type> >&,
                                       const Vector<complex<Type> >& );
	template<typename Type>
	Vector<complex<Type> > svdLnSolver( const Matrix<complex<Type> >&,
                                        const Vector<complex<Type> >& );


	#include <linequs2-impl.h>

}
// namespace splab


#endif
// UNDETLINEQUS_H

实现文件：

/*
 * Copyright (c) 2008-2011 Zhang Ming (M. Zhang), zmjerry@163.com
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 2 or any later version.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. A copy of the GNU General Public License is available at:
 * http://www.fsf.org/licensing/licenses
 */


/*****************************************************************************
 *                               linequs2-impl.h
 *
 * Implementation for solving overdetermined and underdetermined linear
 * equations.
 *
 * Zhang Ming, 2010-07 (revised 2010-12), Xi'an Jiaotong University.
 *****************************************************************************/


/**
 * Overdetermined linear equationequations solution by Least Squares
 * Generalized Inverse.
 * A  --->  The m-by-n(m>n) coefficient matrix(Full Column Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 least squares solution vector.
 */
template <typename Type>
Vector<Type> lsSolver( const Matrix<Type> &A, const Vector<Type> &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() > A.cols() );

    Cholesky<Type> cho;
    cho.dec( trMult(A,A) );
    if( cho.isSpd() )
        return cho.solve( trMult(A,b) );
    else
        return luSolver( trMult(A,A), trMult(A,b) );
}


/**
 * Overdetermined linear equationequations solution by QR Decomposition.
 * A  --->  The m-by-n(m>n) coefficient matrix(Full Column Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 least squares solution vector.
 */
template <typename Real>
Vector<Real> qrLsSolver( const Matrix<Real> &A, const Vector<Real> &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() > A.cols() );

    QRD<Real> qr;
    qr.dec( A );
    if( !qr.isFullRank() )
    {
        cerr << "The matrix A is not Full Rank!" << endl;
        return Vector<Real>();
    }
    else
        return qr.solve( b );
}


/**
 * Overdetermined linear equationequations solution by SVD Decomposition.
 * A  --->  The m-by-n(m>n) coefficient matrix(Full Column Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 least squares solution vector.
 */
template<typename Real>
Vector<Real> svdLsSolver( const Matrix<Real> &A, const Vector<Real> &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() > A.cols() );

    SVD<Real> svd;
    svd.dec( A );
    Matrix<Real> U = svd.getU();
    Matrix<Real> V = svd.getV();
    Vector<Real> s = svd.getSV();

//    for( int i=0; i<V.rows(); ++i )
//        for( int k=0; k<s.dim(); ++k )
//            V[i][k] /= s[k];
//
//    return V * trMult(U,b);

    return V * ( trMult(U,b) / s );
}


/**
 * Overdetermined linear equationequations solution by QR Decomposition.
 * A  --->  The m-by-n(m>n) coefficient matrix(Full Column Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 least squares solution vector.
 */
template<typename Type>
Vector<complex<Type> > qrLsSolver( const Matrix<complex<Type> > &A,
                                   const Vector<complex<Type> > &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() > A.cols() );

    CQRD<Type> qr;
    qr.dec( A );
    if( !qr.isFullRank() )
    {
        cerr << "The matrix A is not Full Rank!" << endl;
        return Vector<complex<Type> >();
    }
    else
        return qr.solve( b );
}


/**
 * Overdetermined linear equationequations solution by SVD Decomposition.
 * A  --->  The m-by-n(m>n) coefficient matrix(Full Column Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 least squares solution vector.
 */
template<typename Type>
Vector<complex<Type> > svdLsSolver( const Matrix<complex<Type> > &A,
                                    const Vector<complex<Type> > &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() > A.cols() );

    CSVD<Type> svd;
    svd.dec( A );
    Matrix<complex<Type> > U = svd.getU();
    Matrix<complex<Type> > V = svd.getV();
    Vector<Type> s = svd.getSV();

//    for( int i=0; i<V.rows(); ++i )
//        for( int k=0; k<s.dim(); ++k )
//            V[i][k] /= s[k];
//
//    return V * trMult(U,b);

    return V * ( trMult(U,b) / complexVector(s) );
}


/**
 * Undetermined linear equationequations solution by Minimum Norm
 * Generalized Inverse.
 * A  --->  The m-by-n(m<n) coefficient matrix(Full Row Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 minimum norm solution vector.
 */
template <typename Type>
Vector<Type> lnSolver( const Matrix<Type> &A, const Vector<Type> &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() < A.cols() );

    Cholesky<Type> cho;
    cho.dec( multTr(A,A) );
    if( cho.isSpd() )
        return trMult( A, cho.solve(b) );
    else
        return trMult( A, luSolver(multTr(A,A),b) );
}


/**
 * Undetermined linear equationequations solution by QR Decomposition.
 * A  --->  The m-by-n(m<n) coefficient matrix(Full Row Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 minimum norm solution vector.
 */
template <typename Real>
Vector<Real> qrLnSolver( const Matrix<Real> &A, const Vector<Real> &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() < A.cols() );

    Matrix<Real> At( trT( A ) );
    QRD<Real> qr;
    qr.dec( At );
    if( !qr.isFullRank() )
    {
        cerr << "The matrix A is not Full Rank!" << endl;
        return Vector<Real>();
    }
    else
    {
        Matrix<Real> Q, R;
        Q = qr.getQ();
        R = qr.getR();
        Vector<Real> y( ltSolver( trT( R ), b ) );
        return Q * y;
    }
}


/**
 * Undetermined complex linear equationequations solution by SVD
 * Decomposition.
 * A  --->  The m-by-n(m<n) coefficient matrix(Full Row Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 minimum norm solution vector.
 */
template<typename Real>
Vector<Real> svdLnSolver( const Matrix<Real> &A, const Vector<Real> &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() < A.cols() );

    SVD<Real> svd;
    svd.dec( A );
    Matrix<Real> U = svd.getU();
    Matrix<Real> V = svd.getV();
    Vector<Real> s = svd.getSV();

//    for( int i=0; i<V.rows(); ++i )
//        for( int k=0; k<s.dim(); ++k )
//            V[i][k] /= s[k];
//
//    return V * trMult(U,b);

    return V * ( trMult(U,b) / s );
}


/**
 * Undetermined complex linear equationequations solution by QR
 * Decomposition.
 * A  --->  The m-by-n(m<n) coefficient matrix(Full Row Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 minimum norm solution vector.
 */
template<typename Type>
Vector<complex<Type> > qrLnSolver( const Matrix<complex<Type> > &A,
                                   const Vector<complex<Type> > &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() < A.cols() );

    Matrix<complex<Type> > At( trH( A ) );
    CQRD<Type> qr;
    qr.dec( At );
    if( !qr.isFullRank() )
    {
        cerr << "The matrix A is not Full Rank!" << endl;
        return Vector<complex<Type> >();
    }
    else
    {
        Matrix<complex<Type> > Q, R;
        Q = qr.getQ();
        R = qr.getR();
        Vector<complex<Type> > y( ltSolver( trH( R ), b ) );
        return Q * y;
    }
}


/**
 * Undetermined complex linear equationequations solution by SVD
 * Decomposition.
 * A  --->  The m-by-n(m<n) coefficient matrix(Full Row Rank);
 * b  --->  The n-by-1 right-hand side vector;
 * x  --->  The n-by-1 minimum norm solution vector.
 */
template<typename Type>
Vector<complex<Type> > svdLnSolver( const Matrix<complex<Type> > &A,
                                    const Vector<complex<Type> > &b )
{
    assert( A.rows() == b.size() );
    assert( A.rows() < A.cols() );

    CSVD<Type> svd;
    svd.dec( A );
    Matrix<complex<Type> > U = svd.getU();
    Matrix<complex<Type> > V = svd.getV();
    Vector<Type> s = svd.getSV();

//    for( int i=0; i<V.rows(); ++i )
//        for( int k=0; k<s.dim(); ++k )
//            V[i][k] /= s[k];
//
//    return V * trMult(U,b);

    return V * ( trMult(U,b) / complexVector(s) );
}

测试代码：

/*****************************************************************************
 *                              linequs2_test.cpp
 *
 * Undetermined Linear Equations testing.
 *
 * Zhang Ming, 2010-07 (revised 2010-12), Xi'an Jiaotong University.
 *****************************************************************************/


#define BOUNDS_CHECK

#include <iostream>
#include <iomanip>
#include <linequs2.h>


using namespace std;
using namespace splab;


typedef double  Type;
const   int     M = 3;
const   int     N = 3;


int main()
{
	Matrix<Type> A(M,N), B(M,N);
	Vector<Type> b(N);

    // overdetermined linear equations
    A.resize( 4, 3 );
	A[0][0] = 1;	A[0][1] = -1;	A[0][2] = 1;
	A[1][0] = 1;	A[1][1] = 2;	A[1][2] = 4;
	A[2][0] = 1;	A[2][1] = 3;	A[2][2] = 9;
	A[3][0] = 1;	A[3][1] = -4;	A[3][2] = 16;
	b.resize( 4 );
	b[0]= 1;    b[1] = 2;   b[2] = 3;   b[3] = 4;

	cout << setiosflags(ios::fixed) << setprecision(3);
    cout << "The original matrix A : " << A << endl;
    cout << "The constant vector b : " << b << endl;
	cout << "The least square solution is (using generalized inverse) : "
         << lsSolver( A, b ) << endl;
    cout << "The least square solution is (using QR decomposition) : "
         << qrLsSolver( A, b ) << endl;
    cout << "The least square solution is (using SVD decomposition) : "
         << svdLsSolver( A, b ) << endl;

    Matrix<complex<Type> > cA = complexMatrix( A, A );
    Vector<complex<Type> > cb = complexVector( b );
    cout << "The original complex matrix cA : " << cA << endl;
    cout << "The constant complex vector cb : " << cb << endl;
	cout << "The least square solution is (using generalized inverse) : "
         << lsSolver( cA, cb ) << endl;
    cout << "The least square solution is (using QR decomposition) : "
         << qrLsSolver( cA, cb ) << endl;
    cout << "The least square solution is (using SVD decomposition) : "
         << svdLsSolver( cA, cb ) << endl;

    // undetermined linear equations
    Matrix<Type> At( trT( A ) );
	b.resize( 3 );
	b[0]= 1;	b[1] = 2;   b[2]= 3;
	cout << "The original matrix A : " << At << endl;
    cout << "The constant vector b : " << b << endl;
	cout << "The least norm solution is (using generalized inverse) : "
         << lnSolver( At, b ) << endl;
	cout << "The least norm solution is (using QR decomposition) : "
         << qrLnSolver( At, b ) << endl;
    cout << "The least norm solution is (using SVD decomposition) : "
         << svdLnSolver( At, b ) << endl;

    cA = complexMatrix( At, -At );
    cb = complexVector( b );
    cout << "The original complex matrix cA : " << cA << endl;
    cout << "The constant complex vector cb : " << cb << endl;
	cout << "The least square solution is (using generalized inverse) : "
         << lnSolver( cA, cb ) << endl;
    cout << "The least square solution is (using QR decomposition) : "
         << qrLnSolver( cA, cb ) << endl;
    cout << "The least square solution is (using SVD decomposition) : "
         << svdLnSolver( cA, cb ) << endl;

	return 0;
}

运行结果：

The original matrix A : size: 4 by 3
1.000   -1.000  1.000
1.000   2.000   4.000
1.000   3.000   9.000
1.000   -4.000  16.000

The constant vector b : size: 4 by 1
1.000
2.000
3.000
4.000

The least square solution is (using generalized inverse) : size: 3 by 1
0.909
0.079
0.212

The least square solution is (using QR decomposition) : size: 3 by 1
0.909
0.079
0.212

The least square solution is (using SVD decomposition) : size: 3 by 1
0.909
0.079
0.212

The original complex matrix cA : size: 4 by 3
(1.000,1.000)   (-1.000,-1.000) (1.000,1.000)
(1.000,1.000)   (2.000,2.000)   (4.000,4.000)
(1.000,1.000)   (3.000,3.000)   (9.000,9.000)
(1.000,1.000)   (-4.000,-4.000) (16.000,16.000)

The constant complex vector cb : size: 4 by 1
(1.000,0.000)
(2.000,0.000)
(3.000,0.000)
(4.000,0.000)

The least square solution is (using generalized inverse) : size: 3 by 1
(0.455,-0.455)
(0.039,-0.039)
(0.106,-0.106)

The least square solution is (using QR decomposition) : size: 3 by 1
(0.455,-0.455)
(0.039,-0.039)
(0.106,-0.106)

The least square solution is (using SVD decomposition) : size: 3 by 1
(0.455,-0.455)
(0.039,-0.039)
(0.106,-0.106)

The original matrix A : size: 3 by 4
1.000   1.000   1.000   1.000
-1.000  2.000   3.000   -4.000
1.000   4.000   9.000   16.000

The constant vector b : size: 3 by 1
1.000
2.000
3.000

The least norm solution is (using generalized inverse) : size: 4 by 1
0.373
0.421
0.336
-0.130

The least norm solution is (using QR decomposition) : size: 4 by 1
0.373
0.421
0.336
-0.130

The least norm solution is (using SVD decomposition) : size: 4 by 1
0.373
0.421
0.336
-0.130

The original complex matrix cA : size: 3 by 4
(1.000,-1.000)  (1.000,-1.000)  (1.000,-1.000)  (1.000,-1.000)
(-1.000,1.000)  (2.000,-2.000)  (3.000,-3.000)  (-4.000,4.000)
(1.000,-1.000)  (4.000,-4.000)  (9.000,-9.000)  (16.000,-16.000)

The constant complex vector cb : size: 3 by 1
(1.000,0.000)
(2.000,0.000)
(3.000,0.000)

The least square solution is (using generalized inverse) : size: 4 by 1
(0.186,0.186)
(0.211,0.211)
(0.168,0.168)
(-0.065,-0.065)

The least square solution is (using QR decomposition) : size: 4 by 1
(0.186,0.186)
(0.211,0.211)
(0.168,0.168)
(-0.065,-0.065)

The least square solution is (using SVD decomposition) : size: 4 by 1
(0.186,0.186)
(0.211,0.211)
(0.168,0.168)
(-0.065,-0.065)


Process returned 0 (0x0)   execution time : 0.140 s
Press any key to continue.

转载于:https://my.oschina.net/zmjerry/blog/6185

weixin_33709609
关注
c++椭圆最小二乘法原理_曲线拟合最小二乘法算法设计及Scala和C++代码实现
weixin_39769039的博客
02-15 299
一、曲线拟合最小二乘原理设实验数据集为，构造的拟合曲线为，则在插值节点处产生的误差为，若想使能够描述原曲线，则应使最小。常使用下列三种标准来度量误差的大小： 曲线拟合最小二乘法选择的是使用向量2-范数最为总体误差的度量标准。具体地，对给定一组实验数据拟构造的曲线为，其中是基函数，是当为极小值时的解。 设多元函数，令 ，具体如下： 设，则上式可以写为：把它改写成矩阵形式为： 这是关于系数的线...
l1范数最小化快速算法
热门推荐
春暖花开
01-15 2万+
1：解决的问题模型如下： 或者约束条件可以适当的松弛，即为如下模型： 当然约束条件取l2l_2范数，bb数据获取的比较准确，结果逼近的效果更好，防止过拟合。如果取l1l_1 范数，则是获取的bb数据，受到污染比较严重。并且bb 本身就是稀疏的。这也是人的经验对于模型的成功也是很重要的。 2：几类优化算法 (1)梯度投影算法Gradient Projection Methods
Loewner方程组极小范数最小二乘解的快速算法 (2010年)
05-24
对于秩为n的mXn阶Loewne矩阵，通过构造分块矩阵并研究其三角分解，进而得到了求线性方程组的极小范数最小二乘解的快速算法，所需运算量为O（mn）+O（m2），而通常构造法方程组的方法所需运算量为0（m2n）+O（ms），用正交化法虽然避免了构造法方程组，但所需的运算量更大。
极小范数解
chen的博客
11-12 394
极小范数解指的是一个使得某个向量的范数（通常是L1范数或L2范数）达到最小值的解。这种解在一些优化问题和机器学习任务中经常出现。在某些情况下，优化问题可能会追求某个向量的L1范数最小化，这通常导致向量中的大部分元素为零，只有少数非零元素。这对于特征选择等问题非常有用，因为它可以帮助识别最重要的特征。LASSO（Least Absolute Shrinkage and Selection Operator）回归就是一个使用L1范数最小化的例子。
数学基础（二）逆矩阵、伪逆矩阵、最小二乘解、最小范数解
Billie使劲学的博客
08-07 3731
举一个多元线性回归的例子：假设都为n维的行向量，N表示样本个数，y为实数。则得到到，其中，为向量中的n个值；就是要估计的参数。 将上式写成矩阵的形式就是我们的目的就是要解出参数a的列向量，则通过下式即可解出a向量。但是通常情况下样本量N并不等于每个样本的维度n，则求的最小值 对a求偏导，导数等于0处去最小值【有没有人知道求偏导后为什么是啊】移项得那么是否可逆呢？如果可逆，就可以通过求得a向量。下面判断是否可逆，当时，有两种情况，N>n 和 Nn其中，，，则 这个就是伪逆矩阵，当X可逆时，它就是......
Ax=b有容的极小范数解
weixin_38817895的博客
12-31 2141
Ax=b有容的极小范数解：为什么用A的（1，3）逆构造极小范数解。
非线性最小二乘估计发射器位置
forFamily
06-24 326
c++实现Levenberg-Marquardt算法 #include <D:\eigen-3.3.9/Eigen/Core> #include <fstream> #include <iostream> #include <D:\eigen-3.3.9/Eigen/Dense> #include <D:\eigen-3.3.9/Eigen/Cholesky> // #include <opencv2/opencv.hpp> #.
SMO（序列最小优化）算法论文及原理详述
weixin_42213622的博客
11-09 4549
今日拜读了Platt的关于SMO的论文：Sequential Minimal Optimization:A Fast Algorithm for Training Support Vector Machines。直译过来就是：序列最小优化：一种训练支持向量机的快速方法。 文章目录一、论文内容概述论文摘要1 简介部分1.2 以前的支持向量方法2 序列最小优化2.1求解两个拉格朗日乘数2.2选择优化哪个乘数的启发式方法2.3阈值计算2.4线性支持向量机的优化2.5 代码细节2.6与以往算法的关系3基准SMO3
矩阵理论探析：广义逆矩阵与线性方程组解法
在矩阵论中，一个m×n矩阵A的广义逆矩阵并不唯一，但有四种常见的类型：A-（减号逆或g-逆）、A/-（最小二乘广义逆）、A二（极小范数广义逆）和A+（加号逆或Moore-Penrose广义逆）。这些广义逆矩阵与线性方程组的解...
矩阵分析学习（最小范数解与极小最小二乘解）
）梦想之深邃（
12-02 1万+
广义逆矩阵与线性方程组的解： 设有线性方程组 Ax=b，在这里A是m*n的矩阵，b为m*1的矩阵；如果m=n且A可逆，则Ax=b有唯一解x=(A^-1)b 或者m != n 或 m = n但A不可逆，方程组不一定有解，即便是有解，解的个数也不一定唯一。 定理：n*m矩阵G是m*n矩阵A的一个{1}-广义逆，当且仅当AGA=A； （注：这里的X、Y、Z为任意矩阵，一般取O矩阵即可，Q和P...
最小范数法
最新发布
weixin_43608857的博客
12-14 647
共轭梯度算法通过权系数的引进克服了无加权的最小二乘法的局限性，权系数使用经过二值化的质量图，它们的目的是对干涉相位图中由于残余点的存在而破坏的区域赋予零权，阻止它们对相位展开的破坏，共轭梯度算法首先使用无加权的最小二乘法作为预处理来加速收敛，之后采用共轭梯度算法迭代获得相位展开的结果。最小二乘法是最小范数法中的一种，总体来说最小范数法解包裹的过程是一个曲面拟合的过程，选取不同的范数就确定了在保证解包裹相位梯度与包裹相位梯度之差最小的条件下，这种相位梯度之差的空间分布情况。
线性最小二乘问题的数值解法
weixin_40620694的博客
03-20 2761
线性最小二乘问题的数值解法 这里我们讨论的问题主要是Ax=b，b∉R(A)b\notin R(A)b∈/​R(A)时的处理方法 最小二乘问题的描述 方程组的分类 对于方程组 Ax=b,A∈Cm×n,b∈Cm(1) Ax=b,A\in C^{m\times n},b\in C^m\tag{1} Ax=b,A∈Cm×n,b∈Cm(1) 超定方程组：m>n 欠定方程组：m<n 线性最...
最小二乘法的一般形式和矩阵形式原理推导和代码实现
poxiaozhuimeng的专栏
11-14 1万+
转自：作者：金良（golden1314521@gmail.com） csdn博客：http://blog.csdn.net/u012176591 1.线性代数模型 首先给出最小二乘解的矩阵形式的公式： 推导过程： 条件： 矩阵必须是列满秩矩阵，否则的逆就不会存在。 若A为m×n的矩阵，b为m×1的矩阵，则Ax=b表达了一个线性方程组，
求解矩阵Ax=b最小二乘问题
rourouwanzi1992的博客
05-06 1481
Ax=b最小二乘问题 lstsq的输出包括四部分：回归系数、残差平方和、自变量X的秩、X的奇异值。 import numpy as np A=[[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,0,0]] b=[1,1,1,1,1] X=np.linalg.lstsq(A, b, rcond = -1) print (X[0]) print(A @ X[0]) ...
3.9 极小范数最小二乘广义逆
你的指尖有改变世界的力量
02-07 1318
介绍了矩阵加号逆的定义以及三种求解算法。
最小二范数解
weixin_43490741的博客
02-28 1万+
最小二范数解 子空间投影问题(最小二乘法) 投影向量 b\textbf{b}b向zzz轴和xyxyxy平面投影分别为p1\textbf{p}_{1}p1​和p2\textbf{p}_{2}p2​两个变换矩阵P1\textbf{P}_{1}P1​ 和 P2\textbf{P}_{2}P2​满足如下以上的例子中两个子空间是正交补的。 上面的问题可以描述为，在空间Rn\mathbb{R}^{n}Rn中，...
最小二乘法的SVD实现
qq_35752161的博客
08-01 3588
0.SLAM中SVD进行最小二乘的应用 在SLAM应用中，计算Homography Matrix，Fundamental Matrix，以及做三角化(Triangulation)时，都会用到最小二乘 1.背景 对一堆观测到的带噪声的数据进行最小二乘拟合 2.理论模型 3.优化目标 4.优化过程 5.工程实现 6.对齐次方程，利用S...
矩阵论（二）：广义逆矩阵（下）
niu_123ming的博客
03-18 2183
本文以线性代数知识为基础。关于线代知识，如一些基本的秩（不）等式、零矩阵的判定条件等，可参考下面几篇博客。 矩阵论（零）：线性代数基础知识整理（1）——逆矩阵、初等变换、满秩分解 矩阵论（零）：线性代数基础知识整理（2）——矩阵的秩与向量组的秩 矩阵论（零）：线性代数基础知识整理（3）——矩阵的秩与向量组的秩 矩阵论（零）：线性代数基础知识整理（4）——线性空间与线性变换 矩阵论（零）：线性代数基...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值