[从头学数学] 第202节 矩阵与变换

最新推荐文章于 2022-05-10 11:16:54 发布
最新推荐文章于 2022-05-10 11:16:54 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： 从头学数学 从头学数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mwsister/article/details/51296071
版权
在星历2016年，银河系厄尔斯星球的中华帝国江南行省，工程师阿伟与机器小伟共同探讨了数学中的重要概念——矩阵与变换。他们深入研究了矩阵的性质及其在几何变换中的应用。
摘要由CSDN通过智能技术生成
剧情提要：
[机器小伟]在[工程师阿伟]的陪同下进入了[九转金丹]之第七转的修炼。
这次要研究的是[矩阵与变换]。

正剧开始：


星历2016年05月02日 13:26:38, 银河系厄尔斯星球中华帝国江南行省。
[工程师阿伟]正在和[机器小伟]一起研究[矩阵与变换]。































<span style="font-size:18px;">	if (1) {
		var mathText = new MathText();		
		var matrix = new Matrix();
		
		var x = y = 20;
		
		//希腊字母表(存此用于Ctrl C/V
			//ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
			//αβγδεζηθικλμνξοπρστυφχψω
		

		//例3
		
		var A = [[1, 1], [0, 1]];
		var B = [[1, -1], [-2, 3]];
		var mulAB = matrix.multiple(A, B);
		
		mathText.printMatrix(mulAB, x, y, 100);
		
		x+=120;
		A = [[1, 2], [3, 4]];
		B = [[0, 1], [1, 0]];
		mulAB = matrix.multiple(A, B);
		
		mathText.printMatrix(mulAB, x, y, 100);
		
		
		//例
		A = [[1, 1], [0, 1]];
		B = matrix.deepCopy(A);
		
		for (var i = 0; i < 5; i++) {
			mulAB = matrix.multiple(A, B);
			A = mulAB;
		}
		
		x+=120;
		mathText.printMatrix(mulAB, x, y, 100);
		
	}</span>


 




<span style="font-size:18px;">	if (1) {
		var mathText = new MathText();		
		var matrix = new Matrix();
		
		var x = y = 20;
		
		//希腊字母表(存此用于Ctrl C/V
			//ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
			//αβγδεζηθικλμνξοπρστυφχψω
		
		var rank = 2;
		
		var m1 = [['cosα', '-sinα'], ['sinα', ' cosa']];
		mathText.printMatrix(m1, x, y, 150);
		
		x += 180;
		var m2 = [[1, 0], [0, 1]];
		mathText.printMatrix(m2, x, y, 60);
		
		x += 80;
		m2 = [[1, 0], [0, -1]];
		mathText.printMatrix(m2, x, y, 80);
		
		x += 90;
		m2 = [[-1, 0], [0, 1]];
		mathText.printMatrix(m2, x, y, 80);
		
		x += 90;
		m2 = [[-1, 0], [0, -1]];
		mathText.printMatrix(m2, x, y, 80);
		
		x = 20;
		y+= 150;
		
		var m3 = [[1, 0], [0, 'k']];
		mathText.printMatrix(m3, x, y, 80);
		
		x += 90;
		m3 = [['k', 0], [0, 1]];
		mathText.printMatrix(m3, x, y, 80);
		
		x += 90;
		m3 = [['k_[1]', 0], [0, 'k_[2]']];
		mathText.printMatrix(m3, x, y, 80);
		
		
		x += 90;
		m3 = [[1, 0], ['k', 1]];
		mathText.printMatrix(m3, x, y, 80);
	
	
		var A = [[1,2], [3,4], [5,6], [7,8]];
		var B = [[1,2,3,4], [5,6,7,8]];
		
		var mulAB = matrix.multiple(A, B);
		
		x+=90;
		mathText.printMatrix(mulAB, x, y, 150);
		
		x = 20;
		y+= 150;
		
		A = [[-1, 0], [0, 1]];
		B = [[2], [2]];
		
		mulAB = matrix.multiple(A, B);
		mathText.printMatrix(mulAB, x, y, 40);
		
		x += 50;
		
		A = [[0.866, -0.5], [0.5, 0.866]];
		B = [[1, 2], [0, 1]];
		
		mulAB = matrix.multiple(A, B);
		mathText.printMatrix(mulAB, x, y, 150);
		
		x += 160;
		
		A = [[0.866, -0.5], [0.5, 0.866]];
		B = [[1], [0]];
		
		mulAB = matrix.multiple(A, B);
		mathText.printMatrix(mulAB, x, y, 70);
		
		x += 80;
		
		A = [[1, 2], [0, 1]];
		B = mulAB;
		
		mulAB = matrix.multiple(A, B);
		mathText.printMatrix(mulAB, x, y, 70);
		
		x += 80;
		A = [[0.866, -0.5], [0.5, 0.866]];
		B = [[1, 2], [0, 1]];
		mulAB = matrix.multiple(A, B);
		mathText.printMatrix(mulAB, x, y, 150);
	}</span>

 
<span style="font-size:18px;">	//矩阵书写，给一块区域的左上角坐标及范围宽度和高度
	//可以比较美观的写出矩阵
	this.printMatrix = function(matrix, leftUpPointX, leftUpPointY, regionWidth, regionHeight) {
		leftUpPointX = leftUpPointX ? leftUpPointX : 20;
		leftUpPointY = leftUpPointY ? leftUpPointY : 20;
		regionWidth = regionWidth ? regionWidth : 200;
		
		
		var row = matrix.length;
		var col = matrix[0].length;
		var gap = 10;
		regionHeight = regionHeight ? regionHeight : row*(20+gap);
		
		
		var cellWidth = regionWidth/col-gap;
		var cellHeight = regionHeight/row - gap;
		
		var x = leftUpPointX;
		var y = leftUpPointY;
		
		var s = '';
		
		plot.save()
			.beginPath()
			.moveTo(x, y)
			.lineTo(x, y+regionHeight)
			.moveTo(x+regionWidth, y)
			.lineTo(x+regionWidth, y+regionHeight)
			.closePath()
			.stroke()
			.restore();
			
		var style = 'black';
		var measure = 0;
		
		
		y += gap+15;
		
		
		var s1 = '';
		var len = 0;
		var count = 0;
				
				
		for (var i = 0; i < row; i++) {
			for (var j = 0; j < col; j++) {
				s = matrix[i][j].toString();
				
				len = s.length;
				s1 = '';
				count = 0;
				
				//由于字符串中植入了许多格式识别符，这里需要去除掉
				//才能比较准确的确定显示宽度
				for (var n = 0; n < len; n++) {
					if (s[n] == '_' || s[n] == '[' || s[n] == ']' || s[n] == '^') {
						count++;
					}
					else {
						s1 += s[n];
					}
				}
				
				measure = plot.measureText(s1);
				measure -= count/3*10;
				
				x += cellWidth;
				//右对齐
				this.print(s, x-measure*1.5, y, style);
				
				x += gap;
				
			}
			
			x = leftUpPointX;
			y += cellHeight+gap;
		}
	}</span>


 






<span style="font-size:18px;">	if (1) {
		var matrix = new Matrix();
		
		var d = matrix.delta([[3,1], [4, 2]]);
		document.write(d);
	}</span>

 
<span style="font-size:18px;">3.00 , 1.00 , 
4.00 , 2.00 , 
2
1.00 , 2.00 , 
3.00 , 4.00 , 
-2
1.00 , 0.00 , 
1.00 , 0.00 , 
0
5.00 , -3.00 , 
2.00 , -1.00 , 
1
1.00 , 0.00 , 
0.00 , -1.00 , 
-1
1.00 , 0.00 , 
0.00 , -1.00 , 
6.00 , -3.00 , 
-4.00 , 2.00 , 
0
0.00 , 
3.00 , 2.00 , 
1.00 , -1.00 , 
-5
0.20 , 0.40 , 
0.20 , -0.60 , 

	if (1) {
		var matrix = new Matrix();
		
		var d = matrix.delta([[3,1], [4, 2]]);
		matrix.print([[3,1], [4, 2]]);
		document.write(d+'<br/>');
		
		d = matrix.delta([[1, 2], [3, 4]]);
		matrix.print([[1, 2], [3, 4]]);
		document.write(d+'<br/>');
		
		d = matrix.delta([[1, 0], [1, 0]]);
		matrix.print([[1, 0], [1, 0]]);
		document.write(d+'<br/>');
		
		d = matrix.delta([[5, -3], [2, -1]]);
		matrix.print([[5, -3], [2, -1]]);
		document.write(d+'<br/>');
		
		var m = [[1, 0], [0, -1]];
		matrix.print([[1, 0], [0, -1]]);
		d = matrix.delta(m);
		document.write(d+'<br/>');
		
		var inv = matrix.invOfRank2(m);
		matrix.print(inv);
		
		m = [[6, -3], [-4, 2]];
		d = matrix.delta(m);
		matrix.print(m);
		document.write(d+'<br/>');		
		inv = matrix.invOfRank2(m);
		matrix.print(inv);
		
		m = [[3, 2], [1, -1]];
		d = matrix.delta(m);
		matrix.print(m);
		document.write(d+'<br/>');		
		inv = matrix.invOfRank2(m);
		matrix.print(inv);
		
		
	}</span>


 



<span style="font-size:18px;">-----原矩阵----
3.00 , 1.00 , 
4.00 , 2.00 , 
-----逆矩阵----
1.00 , -0.50 , 
-2.00 , 1.50 , 
-----解矩阵----
2.00 , 
-4.00 , 
----- ----
-----原矩阵----
1.00 , 2.00 , 
0.00 , 1.00 , 
-----逆矩阵----
1.00 , -2.00 , 
0.00 , 1.00 , 
-----解矩阵----
-1.00 , 
1.00 , 
----- ----
-----原矩阵----
0.71 , -0.71 , 
0.71 , 0.71 , 
-----逆矩阵----
0.71 , 0.71 , 
-0.71 , 0.71 , 
-----解矩阵----
0.00 , 
1.41 , 
----- ----
-----原矩阵----
5.00 , -3.00 , 
2.00 , -1.00 , 
-----逆矩阵----
-1.00 , 3.00 , 
-2.00 , 5.00 , 
-----解矩阵----
-7.00 , 
-12.00 , 
----- ----
-----原矩阵----
3.00 , 2.00 , 
1.00 , 1.00 , 
-----逆矩阵----
1.00 , -2.00 , 
-1.00 , 3.00 , 
-----解矩阵----
4.00 , 
-6.00 , 
----- ----
-----原矩阵----
3.00 , 1.00 , 
4.00 , 2.00 , 
-----逆矩阵----
1.00 , -0.50 , 
-2.00 , 1.50 , 
-----解矩阵----
0.50 , 
0.50 , 
----- ----

	if (1) {
		var matrix = new Matrix();
		
		//例
		var m = [[3, 1], [4, 2]];
		var v = [[2], [0]];
		var inv = matrix.invOfRank2(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----逆矩阵----'+'<br/>');
		matrix.print(inv);
		document.write('-----解矩阵----'+'<br/>');
		var mul = matrix.multiple(inv, v);
		matrix.print(mul);
		document.write('----- ----'+'<br/>');
		

		m = [[1, 2], [0, 1]];
		v = [[1], [1]];
		inv = matrix.invOfRank2(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----逆矩阵----'+'<br/>');
		matrix.print(inv);
		document.write('-----解矩阵----'+'<br/>');
		mul = matrix.multiple(inv, v);
		matrix.print(mul);
		document.write('----- ----'+'<br/>');
		
		m = [[0.707, -0.707], [0.707, 0.707]];
		v = [[-1], [1]];
		inv = matrix.invOfRank2(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----逆矩阵----'+'<br/>');
		matrix.print(inv);
		document.write('-----解矩阵----'+'<br/>');
		mul = matrix.multiple(inv, v);
		matrix.print(mul);
		document.write('----- ----'+'<br/>');
		
		m = [[5, -3], [2, -1]];
		v = [[1], [-2]];
		inv = matrix.invOfRank2(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----逆矩阵----'+'<br/>');
		matrix.print(inv);
		document.write('-----解矩阵----'+'<br/>');
		mul = matrix.multiple(inv, v);
		matrix.print(mul);
		document.write('----- ----'+'<br/>');
		
				m = [[3, 2], [1, 1]];
		v = [[0], [-2]];
		inv = matrix.invOfRank2(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----逆矩阵----'+'<br/>');
		matrix.print(inv);
		document.write('-----解矩阵----'+'<br/>');
		mul = matrix.multiple(inv, v);
		matrix.print(mul);
		document.write('----- ----'+'<br/>');
		
						m = [[3, 1], [4, 2]];
		v = [[2], [3]];
		inv = matrix.invOfRank2(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----逆矩阵----'+'<br/>');
		matrix.print(inv);
		document.write('-----解矩阵----'+'<br/>');
		mul = matrix.multiple(inv, v);
		matrix.print(mul);
		document.write('----- ----'+'<br/>');
	}</span>


 






<span style="font-size:18px;">	if (1) {
		var matrix = new Matrix();
		
		//例
		var m = [[1, 2], [-1, 4]];
		var eigen = matrix.eigenvalue(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----特征矩阵----'+'<br/>');
		matrix.print(eigen);

	}
	
-----原矩阵----
8.00 , -5.00 , 
6.00 , -3.00 , 
-----特征矩阵----
2.00 , 3.00 , 
1.00 , 1.20 , 
1.00 , 1.00 , </span>


 



<span style="font-size:18px;">-----原矩阵----
0.99 , 0.05 , 
0.01 , 0.95 , 
-----特征矩阵----
0.94 , 1.00 , 
1.00 , -1.00 , 
5.00 , 1.00 , 

	if (1) {
		var matrix = new Matrix();
		
		var m = [[0.99,0.05],[0.01,0.95]];		
		
		var eigen = matrix.eigenvalue(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----特征矩阵----'+'<br/>');
		matrix.print(eigen);
	}
	</span>


 


<span style="font-size:18px;">[5, 6], [1, 1]

6.00 , 
7.00 , 
----- ----
13.00 , 
15.00 , 
----- ----
29.00 , 
33.00 , 
----- ----
67.00 , 
75.00 , 
----- ----
161.00 , 
177.00 , 
----- ----
403.00 , 
435.00 , 

	if (1) {
		var matrix = new Matrix();
		
		//习题4.2 -- 1
		var m = [[8, -5], [6, -3]];
		var v = [[6], [7]];
		
		/*
		var eigen = matrix.eigenvalue(m);
		document.write('-----原矩阵----'+'<br/>');
		matrix.print(m);
		document.write('-----特征矩阵----'+'<br/>');
		matrix.print(eigen);
		*/
		
		matrix.print(v);
		var mulAB = matrix.multiple(m, v);
		
		for (var i = 0; i < 5; i++) {
			document.write('----- ----'+'<br/>');
			matrix.print(mulAB);
			
			v = mulAB;
			mulAB = matrix.multiple(m, v);
		}

	}</span>

 
<span style="font-size:18px;">def fun(n):
    A = [2**n*5+3**n, 2**n*6+3**n];
    print(A);
    
def tmp():
    fun(5);
    fun(100);
</span>

矩阵类： 

<span style="font-size:18px;">/**
* @usage   矩阵类
* @author  mw
* @date    2016年03月24日  星期四  14:51:45 
* @param
* @return
*
*/
function Matrix() {
	this.delta = function(matrix) {
		var size = matrix.length;
		
		if (!matrix[0].length) {
			return 0;
		}
		else {
			if (matrix[0].length != size) {
				return 0;
			}
			
			if (size < 1) {
				return 0;
			}
			else if (size == 1) {
				return matrix[0][0];
			}
			else {
				var d = 0;
				var subMatrix = [];
				
				for (var i = 0; i < size; i++) {
					subMatrix = this.subSet(matrix, i, 0);
					d += Math.pow(-1, i)*matrix[i][0]*this.delta(subMatrix);
				}
				return d;
			}
		}
	}
	
	this.subSet = function(matrix, row, col) {	
		var size = matrix.length;
		
		if (!matrix[0].length) {
			return [];
		}
		else {
			if (matrix[0].length != size) {
				return [];
			}
			
			var newMatrix = new Array();
			var rowArray= new Array();
			
			for (var i = 0; i < size; i++) {
				if (i == row) {
					continue;
				}
				else {
					rowArray = [];
				
					for (var j = 0; j < size; j++) {
						if (j == col) {
							continue;
						}
						else {
							rowArray.push(matrix[i][j]);
						}
					}
					
					newMatrix.push(rowArray)
				}
			}
			
			return newMatrix;
		}
	}
	
	this.identityMatrix = function(rank) {
		var newMatrix = new Array();
		var rowArray= new Array();
		
		for (var i = 0; i < rank; i++) {
			rowArray = [];
			
			for (var j = 0; j < rank; j++) {
				if (j == i) {
					rowArray.push(1);
				}
				else {
					rowArray.push(0);
				}
			}
			
			newMatrix.push(rowArray);
		}
		
		return newMatrix;
	}
	
	//建立row*col空矩阵
	this.zeroMatrix = function(row, col) {

		var newMatrix = new Array();
		var rowArray= new Array();
		
		for (var i = 0; i < row; i++) {
			rowArray = [];
			
			for (var j = 0; j < col; j++) {
				rowArray.push(0);
			}
			
			newMatrix.push(rowArray);
		}
		
		return newMatrix;
	}
	
	//把从1-n的n个数按顺序放到矩阵中
	this.sequenceMatrix = function(rank) {
		var newMatrix = new Array();
		var rowArray= new Array();
		
		var count = 0;
		for (var i = 0; i < rank; i++) {
			rowArray = [];
			
			for (var j = 0; j < rank; j++) {
				count++;
				rowArray.push(count);
				
			}
			
			newMatrix.push(rowArray);
		}
		
		return newMatrix;
	}
	
	
	this.print = function(matrix) {
		var size = matrix.length;
		
		if (!matrix[0].length) {
			return [];
		}
		else {
			var rSize = matrix[0].length;
			
			var s = '';
			
			for (var i = 0; i < size; i++) {
				s = '';
				
				for (var j = 0; j < rSize; j++) {
					s += matrix[i][j].toFixed(2) + ' , ';
				}
				
				document.write(s+'<br/>');
			}
		}
	}
					
	this.deepCopy = function(matrix) {
		var size = matrix.length;
		
		if (!matrix[0].length) {
			return [];
		}
		else {
			var rSize = matrix[0].length;
			
			var newMatrix = new Array();
			var rowArray= new Array();
			
			for (var i = 0; i < size; i++) {
				rowArray = [];
				
				for (var j = 0; j < rSize; j++) {
					rowArray.push(matrix[i][j]);
				}
				newMatrix.push(rowArray);
			}
			return newMatrix;
		}
	}
	
/**
* @usage   矩阵的乘法
* @author  mw
* @date    2016年05月02日  星期一  10:44:46 
* @param
* @return
*
*/
	
	this.multiple = function(Matrix1, Matrix2) {
		var row1 = Matrix1.length;
		var col1 = Matrix1[0].length;
		
		
		
		var row2 = Matrix2.length;
		var col2 = Matrix2[0].length;

		var A = [row1, col1, row2, col2];
		
		
		if (col1 != row2) {
			return this.zeroMatrix(row1, col2);
		}
		
		var mulResult = this.zeroMatrix(row1, col2);

		

			for (var i = 0; i < row1; i++) {
				for (var j = 0; j < col2; j++) {
					for (var k = 0; k < row2; k++) {
						mulResult[i][j] += Matrix1[i][k]*Matrix2[k][j];
					}
				}
			}

		
		return mulResult;
		
	}
	
	//二阶矩阵的逆
	this.invOfRank2 = function(Matrix) {
		var d = this.delta(Matrix);
		
		
		if (d != 0) {
			return [[Matrix[1][1]/d, -Matrix[0][1]/d], [-Matrix[1][0]/d, Matrix[0][0]/d]];
		}
		
		else {
			return this.zeroMatrix(2, 2);
		}
		
	}
	
	//二阶矩阵的特征值
	this.eigenvalue = function(Matrix) {
		var a = Matrix[0][0];
		var b = Matrix[0][1];
		var c = Matrix[1][0];
		var d = Matrix[1][1];
		
		var judge = (a+d)*(a+d)-4*(a*d-b*c);
		if ( judge >= 0) {
			var lambda_1 = 0.5*((a+d)-Math.sqrt(judge));
			var lambda_2 = 0.5*((a+d)+Math.sqrt(judge));
		}
		
		
		//特征向量有很多组，这里随便取一组
		//特征值放在第一行，然后是每个特征值对应的一个特征向量
		if (b != 0) {
			return [[lambda_1, lambda_2], [1, (lambda_1-a)/b], [b/(lambda_2-a), 1]];
		}
		else if (c != 0) {
			return [[lambda_1, lambda_2], [1, c/(lambda_1-d)], [(lambda_2-d)/c, 1]];
		}
		
	
	}
	
}</span>

本节到此结束，欲知后事如何，请看下回分解。

mwsister
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3D数学 ---- 矩阵和线性变换 (转载）
zafair的专栏
06-26 5331
3D数学 ---- 矩阵和线性变换 一般来说，方阵能描述任意线性变换。线性变换保留了直线和平行线，但原点没有移动。线性变换保留直线的同时，其他的几何性质如长度、角度、面积和体积可能被变换改变了。从非技术意义上说，线性变换可能“拉伸”坐标系，但不会“弯曲”或“卷折”坐标系。 矩阵是怎样变换向量的向量在几何上能被解释成一系列与轴平行的位移，一般来说，任意向量v都能写成“扩展”形式：
详解矩阵变换：伸缩，旋转，反射和投影
最新发布
forest_LL的博客
01-13 3191
透视变换的转换矩阵也与仿射变换的矩阵不同，是一个 3×3 的矩阵。输入点为(x,y)，经过矩阵变换后为(x,0），该点也是在x轴上且距离输入点最近的点。以上变换中的cx+dy中的x和y可以使多项式，可以是矩阵，还可以是函数x(t)和y(t)，只要满足如上关系都可以看成线性变换。如果给出的矩阵A是m行n列的，那么就可以从n维向量变换到m维向量，换句话说长方形的矩阵（非方阵）也满足如上线性变换。如果输入分别为x和y，对应的输出为x'和y'，那么当输入为求和x+y时，输出也肯定为x'+y'。
矩阵基础与变换
lzzw的学习之路
05-10 3593
矩阵基础 矩阵的基本概念 由 m × n 个数aij排成的m行n列的数表称为m行n列的矩阵，简称m × n矩阵（引用百度百科）。记作： 这m×n 个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列。 矩阵的加法 同型矩阵之间才可以进行相加。减法同理，就是对应元素相减。 单位矩阵 一个矩阵，从左上角到右下角的对角线（称为主对角线）上的元素均为1。除此以外全都为0，称为单位矩阵，通常记为E。 任何矩阵与单位矩阵相乘都等于本身。 矩阵的转置 把矩阵A的行和列互..
矩阵与线性变换
unclerunning的博客
04-28 4万+
矩阵与线性变换矩阵与线性变换 矩阵变换 线性变换 意义 向量旋转变换 拓展 总结 references矩阵变换 Thank about a matrix multiplication as a transformation of space. 对 RnR^n中的每个向量xx，T(x)T(x)由AxAx计算得到，其中AA是m×nm\times n 矩阵，将这样一个矩阵变换记为x→Axx\right
旋转矩阵和变换矩阵
JeffYoung17的博客
09-28 5143
点和向量，坐标系以三维空间为例，一个空间点的位置可以用三个坐标来表示，而对于一个刚体而言，除了在空间的位置，还有自身的姿态，合称为“位姿”。向量是什么? 向量是空间中的一种元素，既有大小，也有方向。有几种表示方式： 代数表示：字母加粗或者字母上加箭头（a⃗ \vec a 或者 a\textbf a ） 几何表示：用一个箭头（线段长度代表向量的大小） 坐标表示：在坐标系中，用坐标可以表示向量，
从头开始学习vue-router
02-24
要学习vue-router就要先知道这里的路由是什么？为什么我们不能像原来一样直接用<a></a>标签编写链接哪？vue-router如何使用？常见路由操作有哪些？等等这些问题，就是本篇要探讨的主要问题。这里的路由并不是指我们...
mini数学矩阵运算库 C语言
05-24
在IT领域，线性代数是基础且至关重要的部分，特别是在科学计算...通过这个"mini数学矩阵运算库 C语言"，开发者能够专注于他们的项目逻辑，而不必从头开始编写这些基础但重要的数学运算，从而提高了开发效率和代码质量。
小学数学教研学习小学数学教学时弊与对策二年级上
09-09
小学数学教学过程中存在一些普遍的问题，这些问题如果不及时解决，可能会对学生的数学学习造成负面影响，阻碍教育改革的深入发展。本文将分析这些问题并提出相应的对策。 首先，讲风太盛是当前小学数学教学的一大...
Photoshop从头学起
07-22
教程名称：Photoshop从头学起课程目录：【】Photoshop从头学起第(1-10)【】Photoshop从头学起第(11-20)【】Photoshop从头学起第(21-30)【】Photoshop从头学起第(31-40)【】Photoshop从头学起第(41-50)【】Photoshop...
线性代数的本质与几何意义 03. 矩阵与线性变换 (3blue1brown 咪博士 图文注解版)
咪博士的博客
12-05 2398
首先，恭喜你读到了咪博士的这篇文章。本文可以说是该系列最重要、最核心的文章。你对线性代数的一切困惑，根源就在于没有真正理解矩阵到底是什么。读完咪博士的这篇文章，你一定会有一种醍醐灌顶、豁然开朗的感觉！ 咱们先来说说啥叫变换。本质上，变换就是函数。 例如，你输入一个向量 [57]， 经过某个变换（即函数）的作用之后，输出另一个向量 [2−3] 既然，变换本质上就是函数，那为啥
矩阵和变换
游戏开发
12-22 841
Godot Matrices and transforms(矩阵和变换) 介绍 在阅读本教程之前，我们建议您彻底阅读并理解矢量数学教程，因为本教程要求您具备矢量知识。 本教程是关于变换以及我们如何在Godot中使用矩阵来表示它们。它不是一个完整深入的矩阵指南。变换大多数时候是以平移、旋转和缩放的方式应用的，所以我们将重点介绍如何用矩阵来表示这些变换。 本指南的大部分内容集中在2D，使用Transform2D和Vector2，但在3D中的工作方式非常相似。 强调文本 强调文本 正如在前面的教程中所提到的，重
矩阵与变换
TXH0001的专栏
09-03 1217
Direct3D中使用矩阵（matrices）来定义世界（world）, 视（view）和投影变换（projection transformation）。如果你以前没有编制过三维图形程序，那么这一部分将向你介绍有关的主要内容。如果你已经对三维图形程序比较熟悉，那么可以跳过这一部分。 矩阵(Matrices) 3-D变换(3-D Transformations) 1. 矩阵
浅谈矩阵变换——Matrix
热门推荐
走向远方
09-05 4万+
矩阵变换在图形学上经常用到。基本的常用矩阵变换操作包括平移、缩放、旋转、斜切。 每种变换都对应一个变换矩阵，通过矩阵乘法，可以把多个变换矩阵相乘得到复合变换矩阵。 矩阵乘法不支持交换律，因此不同的变换顺序得到的变换矩阵也是不相同的。 事实上，图像处理时，矩阵的运算是从右边往左边方向进行运算的。这就形成了越在右边(右乘)的矩阵，越先运算(先乘)，反之亦然
WebGL学习系列-基础矩阵变换
yanyan19880509的专栏
02-26 7307
在图形学中，特别是涉及到3D的时候，矩阵变换起着非常重要的作用。在实际使用的过程当中，通常每一帧画面可能都会涉及到成千上万个顶点的坐标变换，如果没有矩阵变换计算，一个是计算复杂，一个是难以达到我们想要的计算效率。本小节将介绍通过矩阵计算来实现基本的图形变换。
OpenGL学习之矩阵变换实例
qq_33335724的博客
03-14 519
opengl
python 三维数组旋转_【转】【矩阵】三维坐标旋转矩阵算法
weixin_39863918的博客
12-09 2621
一般来说，方阵能描述任意线性变换。线性变换保留了直线和平行线，但原点没有移动。线性变换保留直线的同时，其他的几何性质如长度、角度、面积和体 积可能被变换改变了。从非技术意义上说，线性变换可能“拉伸”坐标系，但不会“弯曲”或“卷折”坐标系。矩阵是怎样变换向量的向量在几何上能被解释成一系列与轴平行的位移，一般来说，任意向量v都能写成“扩展”形式：另一种略有差别的形式为：注意右边的单位向量就是x，y，z...
计算机图形学之矩阵变换的深度理解
papalqi
07-27 2万+
对于图形学来说，矩阵计算不可避免，既直观又方便。而如果线性代数学的不透彻的话，那么基本上是做不到应用的，这里推荐看一下3Blue1Brown的线性代数的视频，可以对矩阵计算有深刻的认识。 之后就是应用阶段，我们这个阶段就是使用我们的矩阵来完成空间中点或向量的各种变换。 重点是理解矩阵的含义：矩阵其实是一种坐标系的转换 理解矩阵的几何功能: 矩阵是一种线性变换（线段变换后仍是线段，并且原点不...
矩阵与矩阵变换
u010029439的博客
12-07 2976
矩阵与矩阵变换 狐狸菌_0e6a关注 2019.03.17 15:06:14字数 1,340阅读 2,888 一、矩阵 矩阵是由 m X n 个标量组成的长方形数组；矩阵属于网格结构，有行、列之分。 实际上矢量可以看成nX1的列矩阵或者1Xn的行矩阵，其中n对应了矢量的维度。列如矢量 v=(3,8,6)可以写成下面两种矩阵。 行矩阵与列矩阵 1. 矩阵的运算 矩阵与标量...
如何从头学习python
12-28
从头学习Python可以通过以下步骤进行： 1. 学习基本概念和语法：首先，你需要学习Python的基本概念和语法。这包括变量、数据类型、运算符、条件语句、循环语句等。你可以通过阅读Python的官方文档、参考书籍或在线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值