矩阵转换

最新推荐文章于 2024-01-13 22:22:17 发布
最新推荐文章于 2024-01-13 22:22:17 发布
阅读量906 收藏
点赞数
分类专栏： T 文章标签： object null string import equals list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/redvalley/article/details/1954624
版权

import  java.util.ArrayList;
 import  java.util.List;

 /**
 * 单元矩阵
 * 
 * @author zfzheng
 * @version 2004-11-15
 */
public   class  CellMatrix  {

 private CellMatrix() {
 }

 public static void dumpMatrix(Object[][] dd) {
  for (int i = 0; i < dd.length; i++) {
   for (int j = 0; j < dd[i].length; j++) {
    System.out.print(" " + dd[i][j]);
   }
   System.out.println();
  }
 }

 public static String getDumpMatrixString(Object[][] dd) {
  StringBuffer sb = new StringBuffer();
  for (int i = 0; i < dd.length; i++) {
   for (int j = 0; j < dd[i].length; j++) {
    sb.append(dd[i][j]).append("  ");
   }
   sb.append(" ");
  }
  return sb.toString();
 }

 /**
  * 列表转换为列矩阵
  */
 public static Object[][] listToMatrix(List list) {
  Object[][] objs = new Object[list.size()][1];
  for (int i = 0; i < objs.length; i++) {
   objs[i] = new Object[1];
   objs[i][0] = list.get(i);
  }
  return objs;
 }

 /**
  * 对角线翻转
  */
 public static Object[][] turnCatercorner(Object[][] dd) {
  if (dd == null || dd.length == 0) {
   return dd;
  }
  int rows = dd.length;
  int cols = dd[0].length;
  Object[][] dd2 = new Object[cols][rows];
  for (int i = 0; i < rows; i++) {
   for (int j = 0; j < cols; j++) {
    dd2[j][i] = dd[i][j];
   }
  }
  return dd2;
 }

 /**
  * 顺时针翻转90度
  */
 public static Object[][] turnClockwise(Object[][] dd) {
  if (dd == null || dd.length == 0) {
   return dd;
  }
  int rows = dd.length;
  int cols = dd[0].length;
  Object[][] dd2 = new Object[cols][rows];
  for (int i = 0; i < rows; i++) {
   for (int j = 0; j < cols; j++) {
    dd2[j][rows - i - 1] = dd[i][j];
   }
  }
  return dd2;
 }

 /**
  * 逆时针翻转90度
  */
 public static Object[][] turnAntiClockwise(Object[][] dd) {
  if (dd == null || dd.length == 0) {
   return dd;
  }
  int rows = dd.length;
  int cols = dd[0].length;
  Object[][] dd2 = new Object[cols][rows];
  for (int i = 0; i < rows; i++) {
   for (int j = 0; j < cols; j++) {
    dd2[cols - j - 1][i] = dd[i][j];
   }
  }
  return dd2;
 }

 /**
  * 表笛卡儿乘积(与sql select两表同)
  */
 public static Object[][] descartesProduct(Object[][] dd1, Object[][] dd2) {
  if (dd1 == null || dd1.length == 0) {
   return dd2;
  }
  if (dd2 == null || dd2.length == 0) {
   return dd1;
  }

  int row1 = dd1.length;
  int col1 = dd1[0].length;

  int row2 = dd2.length;
  int col2 = dd2[0].length;

  Object[][] objs = new Object[row1 * row2][col1 + col2];

  for (int i = 0; i < objs.length; i++) { //行
   objs[i] = new Object[col1 + col2];
   for (int j = 0; j < col1 + col2; j++) { //列
    if (j < col1) {
     objs[i][j] = dd1[i / row2][j];
    } else {
     objs[i][j] = dd2[i % row2][j - col1];
    }
   }
  }
  return objs;
 }

 /**
  * 水平级乘积
  */
 public static Object[][] horizontalLevelProduct(Object[][] dd1,
   Object[][] dd2) {
  return turnClockwise(descartesProduct(dd1, turnAntiClockwise(dd2)));
 }

 /**
  * 连接矩阵，数据为向下水平对齐，其余填充null
  */
 public static Object[][] join(Object[][] dd1, Object[][] dd2) {
  if (dd1 == null || dd1.length == 0) {
   return dd2;
  }
  if (dd2 == null || dd2.length == 0) {
   return dd1;
  }
  int row1 = dd1.length;
  int row2 = dd2.length;
  int row = Math.max(row1, row2);
  int col1 = dd1[0].length;
  int col2 = dd2[0].length;
  int col = col1 + col2;
  Object[][] re = new String[row][col];

  if (row1 > row2) {
   for (int i = 0; i < row1; i++) {
    for (int j = 0; j < col1; j++) {
     re[i][j] = dd1[i][j];
    }
   }
   int n = row1 - row2;
   for (int i = 0; i < row2; i++) {
    for (int j = 0; j < col2; j++) {
     re[i + n][j + col1] = dd2[i][j];
    }
   }

  } else {
   int n = row2 - row1;
   for (int i = 0; i < row1; i++) {
    for (int j = 0; j < col1; j++) {
     re[i + n][j] = dd1[i][j];
    }
   }
   for (int i = 0; i < row; i++) {
    for (int j = 0; j < col2; j++) {
     re[i][j + col1] = dd2[i][j];
    }
   }
  }
  return re;
 }

 
 public static List parseAutoMatchMergeRegion(Object[][] dd) { 
  return parseAutoMatchMergeRegion(dd,true,true,true);
 }
 
 /**
  * 自动匹配融合区，返回融合区域列表
  * @param rowDir 横向融合
  * @param colDir 纵向融合
  * @return list#{x1,y1,x2,y2}
  */ 
 public static List parseAutoMatchMergeRegion(Object[][] dd,boolean rowDir, boolean colDir,boolean withNullEq) {
  List list = new ArrayList();
  if (dd == null || dd.length == 0 || (!rowDir&&!colDir)) {
   return list;
  }
  List keyList = new ArrayList();

  int rows = dd.length;
  int cols = dd[0].length;
  Object lastKey = null;
  Object curKey = null;
  int len = 0;
  if(rowDir){
   //横向
   for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
     curKey = dd[i][j];
     if (j == 0) {
      lastKey = curKey;
      len = 0;
      continue;
     }
     if ((j != cols - 1) && equalsTo(curKey, lastKey ,withNullEq)) {
      len++;
      continue;
     } else {
      if (j == cols - 1 && equalsTo(curKey, lastKey ,withNullEq)) {
       list.add(new int[] { j - len - 1, i, j, i });
       keyList.add(lastKey);
      } else if (len > 0) {
       list.add(new int[] { j - len - 1, i, j - 1, i });
       keyList.add(lastKey);
      }
      lastKey = curKey;
      len = 0;
     }
    }
   }
  }
  if(colDir){
   //纵向
   for (int i = 0; i < cols; i++) {
    for (int j = 0; j < rows; j++) {
     curKey = dd[j][i];
     if (j == 0) {
      lastKey = curKey;
      len = 0;
      continue;
     }
     if ((j != rows - 1) && equalsTo(curKey, lastKey ,withNullEq)) {
      len++;
      continue;
     } else {
      if (j == rows - 1 && equalsTo(curKey, lastKey ,withNullEq)) {
       list.add(new int[] { i, j - len - 1, i, j });
       keyList.add(lastKey);
      } else if (len > 0) {
       list.add(new int[] { i, j - len - 1, i, j - 1 });
       keyList.add(lastKey);
      }
      lastKey = curKey;
      len = 0;
     }
    }
   }
  }

  if(rowDir&&colDir){
   //合并“融合区”
   int[] last = null;
   int[] cur = null;
   for (int i = 0; i < list.size() - 1; i++) {
    last = (int[]) list.get(i);
    lastKey = keyList.get(i);
    for (int j = i + 1; j < list.size(); j++) {
     cur = (int[]) list.get(j);
     curKey = keyList.get(j);
     if (equalsTo(curKey, lastKey ,withNullEq)) {
      boolean canBeMerge=(last[1] == cur[1] && last[3] == cur[3] && last[2] + 1 >= cur[0])
      || (last[0] == cur[0] && last[2] == cur[2] && last[3] + 1 >= cur[1]);
      if (canBeMerge) {
       list.remove(j);
       list.remove(i);
       keyList.remove(j);
       keyList.remove(i);
       list.add(i, new int[] { last[0], last[1], cur[2],
         cur[3] });
       keyList.add(i, curKey);
       i--;
       break;
      }
     }
    }
   }  
  }
  return list;
 }

 /**
  * 转换矩阵类型
  */
 public static String[][] convert(Object[][] dd, boolean force) {
  if (dd == null) {
   return null;
  } else if (dd.length == 0) {
   return new String[][] {};
  }
  int rows = dd.length;
  int cols = dd[0].length;
  String[][] dd2 = new String[rows][cols];
  for (int i = 0; i < rows; i++) {
   for (int j = 0; j < cols; j++) {
    if (force) {
     dd2[i][j] = (String) dd[i][j];
    } else {
     dd2[i][j] = String.valueOf(dd[i][j]);
    }
   }
  }
  return dd2;
 }
 
 /**
  * 
  * @param value1
  * @param value2
  * @return
  */
 public static boolean equalsTo(Object value1, Object value2,boolean withNullEq) {
  if(value2==null){
   return withNullEq?value1==null:false;
  }else{
   return value2.equals(value1);
  }
 }

 public static boolean equals(Object value1, Object value2) {
  if(value1==null||value2==null){
   return true;
  }
  return value1.equals(value2);
 }
 
 /**
  * 插入列
  * 
  * @param dd
  *            矩阵
  * @param insertIndex
  *            插入位置
  * @param count
  *            插入列数
  * @param defaultValue
  *            插入元素的缺省值
  * @return
  */
 public static Object[][] insertColumns(Object[][] dd, int insertIndex,
   int count, Object defaultValue) {
  if (dd == null || dd.length == 0) {
   return dd;
  }
  int rows = dd.length;
  int cols = dd[0].length;
  int toColumnIndex = insertIndex + count;
  Object[][] dd2 = new Object[rows][cols + count];
  for (int i = 0; i < rows; i++) {
   for (int j = 0, n = cols + count; j < n; j++) {
    if (j <= insertIndex) {
     dd2[i][j] = dd[i][j];
    } else if (j <= toColumnIndex) {
     dd2[i][j] = defaultValue;
    } else {
     dd2[i][j] = dd[i][j - count];
    }
   }
  }
  return dd2;
 }

 /**
  * 删除列
  * 
  * @param dd
  *            矩阵
  * @param ix
  *            要删除的列索引数组
  * @return
  */
 public static Object[][] removeColumns(Object[][] dd, int[] ix) {
  if (dd == null || dd.length == 0) {
   return dd;
  }
  int rows = dd.length;
  int cols = dd[0].length;
  Object[][] dd2 = new Object[rows][cols - ix.length];
  int n = -1;
  boolean canBeRemove = false;
  for (int i = 0; i < cols; i++) {
   canBeRemove = false;
   for (int k = 0; k < ix.length; k++) {
    if (i == ix[k]) {
     canBeRemove = true;
     break;
    }
   }
   if (canBeRemove) {
    continue;
   }
   n++;
   for (int j = 0; j < rows; j++) {
    dd2[j][n] = dd[j][i];
   }
  }
  return dd2;
 }

 public static Object[][] removeRows(Object[][] dd, int[] ix) {
  if (dd == null || dd.length == 0) {
   return dd;
  }
  int rows = dd.length;
  int cols = dd[0].length;
  Object[][] dd2 = new Object[rows - ix.length][cols];
  int n = -1;
  boolean canBeRemove = false;
  for (int i = 0; i < rows; i++) {
   canBeRemove = false;
   for (int k = 0; k < ix.length; k++) {
    if (i == ix[k]) {
     canBeRemove = true;
     break;
    }
   }
   if (canBeRemove) {
    continue;
   }
   n++;
   for (int j = 0; j < cols; j++) {
    dd2[n][j] = dd[i][j];
   }
  }
  return dd2;
 }
}

 
redvalley
关注
专栏目录
矩阵转置java程序
04-03
一个java程序，能够对一个4x4的矩阵进行行列互换。测试数据采用随机数据，每个单元的取值为10~100的整数。
将非正定对称矩阵转换为正定对称矩阵：将非正定对称矩阵转换为正定矩阵的函数。-matlab开发
06-01
在MATLAB环境中，将非正定对称矩阵转换为正定对称矩阵是解决特定问题时经常遇到的需求，比如在处理协方差矩阵或者优化问题时。正定矩阵具有许多有益的性质，如所有特征值均为正，可以保证逆矩阵的存在，以及与之相关...
矩阵变换
weixin_33826268的博客
04-19 96
在一些算法中需要用到矩阵，自然就需要用到矩阵的一些操作，比如行变换、列变换、最简式、求矩阵的秩等，下面是实现的代码 public class Matrix { #region 属性 /// <summary> /// 行数 /// </summary> ...
将协方差矩阵转换为相关矩阵：将协方差矩阵转换为相关矩阵，在其主对角线上设置为 1-s-matlab开发
06-01
该函数是原生 matlab cov2corr() 函数的“重新混合”，它生成相关矩阵，其主对角线上的元素略大于或小于 1。因此它不能用于各种进一步的计算，例如在 squareform() 函数中. 这个问题可以简单地通过将所有对角线元素...
python矩阵转换为一维数组的实例
09-20
在Python编程语言中，处理矩阵和数组数据时，有时我们需要将二维矩阵转换成一维数组。这在数据处理、科学计算或机器学习等场景中非常常见。本篇将详细讲解如何将Python中的矩阵转换为一维数组，并通过一个具体的实例...
Python 实现将数组/矩阵转换成Image类
09-18
本文将详细介绍如何使用Python的`PIL`（Pillow）库将数组或矩阵转换为`Image`类，以便进行进一步的图像处理。 首先，我们要理解为什么需要将数组转换成`Image`类。在某些情况下，我们可能处理的是特殊格式的图像...
Numpy 将二维图像矩阵转换为一维向量的方法
01-21
以下的例子，将32×32的二维矩阵，装换成1×1024的向量 def image2vector ...以上这篇Numpy 将二维图像矩阵转换为一维向量的方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持软件开
矩阵转置的java实现
09-29
矩阵转置的java实现，使用java实现矩阵的转置运算
矩阵转化
Soisini的博客
12-08 1344
C语言矩阵转化，将两行三列变为三行两列。 如： 输入矩阵: 2 3 4 5 6 4 转换后矩阵: 2 5 3 6 4 4 具体来说需要建立两个数组，然后在中途每一项进行转化即可获得你想要的结果，话不多说 附上代码 #include <stdio.h> int main() { int a[10][10], transpose[10][10], r, c, i,...
浅谈矩阵变换——Matrix
热门推荐
走向远方
09-05 4万+
矩阵变换在图形学上经常用到。基本的常用矩阵变换操作包括平移、缩放、旋转、斜切。 每种变换都对应一个变换矩阵，通过矩阵乘法，可以把多个变换矩阵相乘得到复合变换矩阵。 矩阵乘法不支持交换律，因此不同的变换顺序得到的变换矩阵也是不相同的。 事实上，图像处理时，矩阵的运算是从右边往左边方向进行运算的。这就形成了越在右边(右乘)的矩阵，越先运算(先乘)，反之亦然
7.矩阵变换
j_oop的博客
09-07 382
1.使用OpenGL Mathematics，下载GLM后，将文件路径加入包含路径（不需要编译和链接） 2.平移、旋转、缩放矩阵 glm::vec4 vec(1.0f,0.0f,0.0f,1.0f); //默认是一个单位矩阵（9.9版本之后的GLM应改为glm::mat4 trans(1.0f);） glm::mat4 trans; //缩放 trans = glm::scale(trans,glm::vec3(0.5,0.5,0.5)); //旋转 trans = glm::rotate(trans
2.2 矩阵变换
dreamingIT的博客
07-10 1905
写在前面：作者本人是纯纯的菜鸟，学习的内容来自于 中国大学MOOC 中南大学 《科学计算与MATLAB语言》，欢迎各位大佬或新手在这里和平讨论，如果我有错误请各位不吝赐教，提前感谢各位捧场！ 何为矩阵变化？ 指对矩阵进行某种运算与操作，其结果还是一个矩阵。 今天要讲到的矩阵变换： 对角阵 三角阵 矩阵的转置 矩阵的翻转 矩阵的旋转 矩阵求逆 1.对角阵 对角线上有非零元素的矩阵称为对角阵。 数量矩阵：对角线上数字相同的对角矩阵。 单位矩阵：对角线上数字全为1的对角矩阵。 MATLA
矩阵基础与变换
lzzw的学习之路
05-10 3716
矩阵基础 矩阵的基本概念 由 m × n 个数aij排成的m行n列的数表称为m行n列的矩阵，简称m × n矩阵（引用百度百科）。记作： 这m×n 个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列。 矩阵的加法 同型矩阵之间才可以进行相加。减法同理，就是对应元素相减。 单位矩阵 一个矩阵，从左上角到右下角的对角线（称为主对角线）上的元素均为1。除此以外全都为0，称为单位矩阵，通常记为E。 任何矩阵与单位矩阵相乘都等于本身。 矩阵的转置 把矩阵A的行和列互..
如何进行矩阵转换
ajl2003的博客
12-28 2627
矩阵转换其实就通俗的理解就是进行行和列的转换，难点是如何用c语言进行这个操作， 我们可以定义两个数组，一个存放初始化的数组，另一个用来存放转换后的。将a数组的第一行第一列的复制给b数组的第一行第一列，然后将a数组的第一行第二列赋值给b数组的第二行第一列，依次类推就可以得到你的答案了 #include<stdio.h> int main() { int n , m ; scanf("%d%d",&n,&m); int a[n][m],b[m][n];/
详解矩阵变换：伸缩，旋转，反射和投影
最新发布
forest_LL的博客
01-13 3641
透视变换的转换矩阵也与仿射变换的矩阵不同，是一个 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'。
数学-线性代数2(矩阵乘法、逆矩阵、转置-转换-向量空间)
让你爱上电路设计
04-09 5926
本文深入探讨了矩阵乘法的不同方法，包括列组合、行组合、列乘以行和分块乘法。此外，详细阐述了逆矩阵的概念，介绍了求逆矩阵的高斯-若尔当方法以及A的LU分解。同时，文章讨论了矩阵的转置、置换矩阵及其在向量空间中的应用，以及列空间和零空间的定义与性质。通过对矩阵乘法的理解，解析了Ax=b方程的可解性与解的结构，分析了矩阵秩与解的关系，为理解和解决线性代数问题提供了基础。
python矩阵转换数字
05-27
如果想要将一个矩阵转换成一个数字，可以将矩阵中的每个元素按照一定的规则组合成一个数字。 例如，可以将矩阵中的每个元素按照从左到右、从上到下的顺序排列，并将它们组合成一个数字，例如： ```python import numpy as np # 定义一个3x3的矩阵 matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # 将矩阵转换成数字 number = int(''.join([str(i) for i in matrix.flatten()])) ``` 这里使用了numpy库中的`array`函数创建一个3x3的矩阵，然后使用`flatten()`函数将矩阵扁平化为一个一维数组，再使用列表解析式和`join()`函数将数组中的每个元素转换成字符串，并拼接成一个字符串，最后使用`int()`函数将字符串转换成整数，得到一个数字。 执行完毕后，变量`number`就是矩阵转换后的数字。 需要注意的是，如果矩阵中的元素包含多位数字，例如矩阵`[[10, 20], [30, 40]]`，那么需要在拼接字符串时添加一定的分隔符，例如逗号或空格，以避免出现错误的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值