矩阵转换

最新推荐文章于 2024-08-29 08:00:00 发布
原创 最新推荐文章于 2024-08-29 08:00:00 发布 · 948 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#object #null #string #import #equals #list


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;
 }
}

 
矩阵转置java程序
04-03
一个java程序，能够对一个4x4的矩阵进行行列互换。测试数据采用随机数据，每个单元的取值为10~100的整数。
将非正定对称矩阵转换为正定对称矩阵：将非正定对称矩阵转换为正定矩阵的函数。-matlab开发
06-01
在MATLAB环境中，将非正定对称矩阵转换为正定对称矩阵是解决特定问题时经常遇到的需求，比如在处理协方差矩阵或者优化问题时。正定矩阵具有许多有益的性质，如所有特征值均为正，可以保证逆矩阵的存在，以及与之相关...
矩阵变换
weixin_33826268的博客
04-19 149
在一些算法中需要用到矩阵，自然就需要用到矩阵的一些操作，比如行变换、列变换、最简式、求矩阵的秩等，下面是实现的代码 public class Matrix { #region 属性 /// <summary> /// 行数 /// </summary> ...
将协方差矩阵转换为相关矩阵：将协方差矩阵转换为相关矩阵，在其主对角线上设置为 1-s-matlab开发
06-01
该函数是原生 matlab cov2corr() 函数的“重新混合”，它生成相关矩阵，其主对角线上的元素略大于或小于 1。因此它不能用于各种进一步的计算，例如在 squareform() 函数中. 这个问题可以简单地通过将所有对角线元素...
python矩阵转换为一维数组的实例
09-20
在Python编程语言中，处理矩阵和数组数据时，有时我们需要将二维矩阵转换成一维数组。这在数据处理、科学计算或机器学习等场景中非常常见。本篇将详细讲解如何将Python中的矩阵转换为一维数组，并通过一个具体的实例...
Matrix2XYZ:将给定的矩阵转换为 XYZ 向量-matlab开发
06-01
在MATLAB编程环境中，"Matrix2XYZ:将给定的矩阵转换为 XYZ 向量"是一个功能，它允许用户将矩阵数据转换成三维空间中的XYZ坐标向量。这个过程涉及到线性代数和坐标系统的理解，是数据分析和建模中常见的操作。下面...
Numpy 将二维图像矩阵转换为一维向量的方法
01-21
以下的例子，将32×32的二维矩阵，装换成1×1024的向量 def image2vector ...以上这篇Numpy 将二维图像矩阵转换为一维向量的方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持软件开
矩阵转置的java实现
09-29
矩阵转置的java实现，使用java实现矩阵的转置运算
矩阵转化
Soisini的博客
12-08 1430
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万+
矩阵变换在图形学上经常用到。基本的常用矩阵变换操作包括平移、缩放、旋转、斜切。 每种变换都对应一个变换矩阵，通过矩阵乘法，可以把多个变换矩阵相乘得到复合变换矩阵。 矩阵乘法不支持交换律，因此不同的变换顺序得到的变换矩阵也是不相同的。 事实上，图像处理时，矩阵的运算是从右边往左边方向进行运算的。这就形成了越在右边(右乘)的矩阵，越先运算(先乘)，反之亦然
什么是矩阵变换?
...
06-12 1708
矩阵加法和减法：这是最基本的线性运算，直接对应元素相加或相减。例子给定矩阵Aabcd和Befgh，则ABaebfcgdh给定矩阵 A=\begin{pmatrix}a & b\\c & d\end{pmatrix} 和 B=\begin{pmatrix}e & f\\g & h\end{pmatrix}，则 A+B=\begin{pmatrix}a+e & b+f\\c+g & d+h\end{pmatrix}给定矩阵Aac​bd​和Be。
7.矩阵变换
j_oop的博客
09-07 435
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
矩阵的基本变换
qq_44717657的博客
03-21 3307
Java实现矩阵的基本移动 转置矩阵 AES算法中的S_box简单实现
2.2 矩阵变换
dreamingIT的博客
07-10 2007
写在前面：作者本人是纯纯的菜鸟，学习的内容来自于 中国大学MOOC 中南大学 《科学计算与MATLAB语言》，欢迎各位大佬或新手在这里和平讨论，如果我有错误请各位不吝赐教，提前感谢各位捧场！ 何为矩阵变化？ 指对矩阵进行某种运算与操作，其结果还是一个矩阵。 今天要讲到的矩阵变换： 对角阵 三角阵 矩阵的转置 矩阵的翻转 矩阵的旋转 矩阵求逆 1.对角阵 对角线上有非零元素的矩阵称为对角阵。 数量矩阵：对角线上数字相同的对角矩阵。 单位矩阵：对角线上数字全为1的对角矩阵。 MATLA
矩阵转换|python学习笔记（新手小白友好版）
最新发布
专注python+工程实践的热心婶子
08-29 2292
使用ndim模块读取矩阵维数；使用shape模块读取矩阵行列数；使用shape模块修改矩阵行列数；使用reshape模块修改矩阵行列数；使用两层方框嵌套，即写成“[ [ ] ]”的形式可使array定义的一维矩阵形数组行列数，和用matrxi定义的一维矩阵形数数组，使用shape模块读取的行列数一致。
C#实现矩阵运算与字符串矩阵转换
2. **矩阵转换为字符串**：将矩阵转换为字符串通常是为了输出、保存或展示矩阵内容。这个过程可能包括对矩阵中每个元素的格式化，以确保输出的字符串具有清晰的视觉结构，例如将每个元素限制到一定的宽度，使用逗号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值