Java 对称矩阵半矢量化

我面临的问题是如何将给定对称矩阵（它是距离矩阵）的下三角因子存储到向量中

一般来说，我想通过只给出矩形网格上一组点的坐标来直接生成下三角条目的：实际上，这就是我陷入困境的地方

因此，我开始考虑从一个稍微不同的角度来解决这个问题：生成完整的距离矩阵（再次给出

（Y，Z）

对），然后对距离矩阵进行半矢量化

然而，对于如何通过

for

循环来实现目标，我并没有一个好的想法

此外，我还知道可能有任何外部

Java

库实现

vech

函数：vech返回通过消除方阵

X

的所有超对角元素并将结果一列叠加在另一列之上而获得的向量。这在矩阵演算中有应用，在矩阵演算中，基础矩阵是对称的，将值保持在主对角线之上是没有意义的

实质上，给定矩阵

a={{a，c}，{b，d}

，通过应用

vech（a）

，结果将是

vech（A）={A，b，d}

编辑

我的意思是如下所示：

    a11 a12 a13 a14
        a22 a23 a24
 A=         a33 a34  (aij = aji)
                a44

A上部三角形的打包存储：

  AP = { a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 }

我想不出一个库可以让您这样做，尽管我肯定在某个地方有一个库，但您可以使用for循环，如下所示：

ArrayList<ArrayList<int>> matrix = new ArrayList<ArrayList<int>>();
// add other arraylists to your matrix here i.e.:

ArrayList<Integer> first = new ArrayList<Integer>();
first.add(1);
first.add(2);
first.add(3);

ArrayList<Integer> second = new ArrayList<Integer>();
second.add(4);
second.add(5);
second.add(6);

ArrayList<Integer> third = new ArrayList<Integer>();
third.add(7);
third.add(8);
third.add(9);

matrix.add(first);
matrix.add(second);
matrix.add(third);

ArrayList<int> finalArray = new ArrayList<int>();

for(int i=0; i<matrix.size(); i++)
{
    ArrayList<Integer> inner = matrix.get(i);
    for(int j=0; j<i+1; j++)
    {
        finalArray.add(inner.get(j));
    }
}   

ArrayList矩阵=新的ArrayList（）；
//在此处将其他ArrayList添加到矩阵中，即：
ArrayList first=新的ArrayList（）；
第一，加入第（1）款；
第一，加入第（2）款；
第一，加入第（3）款；
ArrayList second=新的ArrayList（）；
第二，增加（4）；
第二条增加第（5）款；
第二，增加（6）；
ArrayList third=新的ArrayList（）；
第三，增加（7）；
第三，增加（8）；
第三，增加（9）；
矩阵。添加（第一）；
矩阵。添加（第二）；
矩阵。添加（第三）；
ArrayList finalArray=新的ArrayList（）；
for（int i=0；i我想不出一个库可以让您这样做，尽管我确信在某个地方有一个库，但您可以使用for循环，如下所示：

ArrayList<ArrayList<int>> matrix = new ArrayList<ArrayList<int>>();
// add other arraylists to your matrix here i.e.:

ArrayList<Integer> first = new ArrayList<Integer>();
first.add(1);
first.add(2);
first.add(3);

ArrayList<Integer> second = new ArrayList<Integer>();
second.add(4);
second.add(5);
second.add(6);

ArrayList<Integer> third = new ArrayList<Integer>();
third.add(7);
third.add(8);
third.add(9);

matrix.add(first);
matrix.add(second);
matrix.add(third);

ArrayList<int> finalArray = new ArrayList<int>();

for(int i=0; i<matrix.size(); i++)
{
    ArrayList<Integer> inner = matrix.get(i);
    for(int j=0; j<i+1; j++)
    {
        finalArray.add(inner.get(j));
    }
}   

ArrayList矩阵=新的ArrayList（）；
//在此处将其他ArrayList添加到矩阵中，即：
ArrayList first=新的ArrayList（）；
第一，加入第（1）款；
第一，加入第（2）款；
第一，加入第（3）款；
ArrayList second=新的ArrayList（）；
第二，增加（4）；
第二条增加第（5）款；
第二，增加（6）；
ArrayList third=新的ArrayList（）；
第三，增加（7）；
第三，增加（8）；
第三，增加（9）；
矩阵。添加（第一）；
矩阵。添加（第二）；
矩阵。添加（第三）；
ArrayList finalArray=新的ArrayList（）；
对于（int i=0；i，关于所有这些打包还有一件有趣的事情。您还可以定义一个映射算法，将对称矩阵中的
（i，j）
位置转换为展平数组中的等效偏移量（就像您描述的那样）。您可以使用的思想来定义此类映射。我是在中处理类时这样做的。因此，您可以使用这些公式（它不处理
I==j
时的情况）：

int展平（int i，int j）{
整数偏移量=-1；
if（i

，其中，
size
是对称矩阵的大小。
关于所有这些打包还有一件有趣的事情。您还可以定义一个映射算法，将对称矩阵中的
（i，j）
位置转换为展平数组中的等效偏移量（如您所述）。您可以使用的思想来定义此类映射。我是在中处理类时这样做的。因此，您可以使用这些公式（它不处理
I==j
时的情况）：

int展平（int i，int j）{
整数偏移量=-1；
if（i

，其中，
size
是对称矩阵的大小。
最后一句话；到目前为止你尝试了什么？@OliCharlesworth:我尝试了几个For循环，但没有成功，我将编辑我的问题，包括我的试用。我建议交换你的问题-首先询问如何使用standard For loops进行此操作，然后提到你也喜欢e想了解一个库，否则这个问题就没有建设性。最后一句话，你尝试了什么？@OliCharlesworth:我已经尝试了几个For循环，但没有成功，我将编辑我的问题，包括我的试用。我建议交换你的问题-先问一下如何使用standard For loops，然后再问一下假设你也想了解一个库，否则这个问题就没有建设性。如果我想以
column major
的方式访问
v
元素，行major和列major之间的区别是
[I][j]
↔ 
[j][i]
或主对角线中的镜像。如果我想以
列主键
的方式访问
v
元素，行主键和列主键之间的区别是
[i][j]
↔ <代码>[j][i]
或主对角线中的镜像。
            a[j][i]

ArrayList<ArrayList<int>> matrix = new ArrayList<ArrayList<int>>();
// add other arraylists to your matrix here i.e.:

ArrayList<Integer> first = new ArrayList<Integer>();
first.add(1);
first.add(2);
first.add(3);

ArrayList<Integer> second = new ArrayList<Integer>();
second.add(4);
second.add(5);
second.add(6);

ArrayList<Integer> third = new ArrayList<Integer>();
third.add(7);
third.add(8);
third.add(9);

matrix.add(first);
matrix.add(second);
matrix.add(third);

ArrayList<int> finalArray = new ArrayList<int>();

for(int i=0; i<matrix.size(); i++)
{
    ArrayList<Integer> inner = matrix.get(i);
    for(int j=0; j<i+1; j++)
    {
        finalArray.add(inner.get(j));
    }
}   

int flatten(int i, int j) {
  int offset = -1;

  if (i < j) {
    offset = j - (i + 1) + (int)((((size - 1) + (size - i)) / 2.0) * i);
  } else {
    offset = i - (j + 1) + (int)((((size - 1) + (size - j)) / 2.0) * j);
  }

  return offset;
}