blocks|key|1224322|text|还有第四种选择:使用一个减少的数组--大数组。我将使用选项1(使用完整的数组并只存储每个元素两次)或最后一个选项。如果您打算更新许多元素，我强烈建议使用可变数组；IOArray和STArray是流行的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1224323|除非这是为了家庭作业什么的，否则你也应该看看黑客。快速观察表明，操纵矩阵的问题已经解决了好几次了。|1224324|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

There is a fourth option: use an array of decreasingly-large arrays. I would go with either option 1 (using a full array and just storing every element twice) or this last one. If you intend to be updating a lot of elements, I strongly recommend using a mutable array; IOArray and STArray are popular choices.

Unless this is for homework or something, you should also take a peek at Hackage. A quick look suggests the problem of manipulating matrices has been solved several times already.

blocks|key|3457809|text|您可以尝试使用只生成矩阵上半部分的专用Ix类来使用Data.Array：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3457810|newtype+Symmetric+=+Symmetric+{+pair+::+(Int,+Int)+}+deriving+(Ord,+Eq)

instance+Ix+Symmetric+where
++++range+((Symmetric+(x1,y1)),+(Symmetric+(x2,y2)))+=
++++++++map+Symmetric+[(x,y)+%7C+x+<-+range+(x1,x2),+y+<-+range+(y1,y2),+x+>=+y]
++++inRange+(lo,hi)+i+=+x+<=+hix+&&+x+>=+lox+&&+y+<=+hiy+&&+y+>=+loy+&&+x+>=+y
++++++++where
++++++++++(lox,loy)+=+pair+lo
++++++++++(hix,hiy)+=+pair+hi
++++++++++(x,y)+=+pair+i
++++index+(lo,hi)+i
++++++++%7C+inRange+(lo,hi)+i++=+(x-loy)%2B(sum$take(y-loy)[hix-lox,+hix-lox-1..])
++++++++%7C+otherwise+=+error+"Error+in+array+index"
++++++++where
++++++++++(lox,loy)+=+pair+lo
++++++++++(hix,hiy)+=+pair+hi
++++++++++(x,y)+=+pair+i

sym+x+y+
++++%7C+x+<+y+=+Symmetric+(y,x)
++++%7C+otherwise+=+Symmetric+(x,y)



*Main+Data.Ix>+let+a+=+listArray+(sym+0+0,+sym+6+6)+[0..]
*Main+Data.Ix>+a+!+sym+3+2
14
*Main+Data.Ix>+a+!+sym+2+3
14
*Main+Data.Ix>+a+!+sym+2+2
13
*Main+Data.Ix>+length+$+elems+a
28
*Main+Data.Ix>+let+b+=+listArray+(sym+0+0,+sym+19+19)+[0..]
*Main+Data.Ix>+length+$+elems+b
210|code-block|syntax|javascript|3457811|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could try using Data.Array using a specialized Ix class that only generates the upper half of the matrix:

<pre><code>newtype Symmetric = Symmetric { pair :: (Int, Int) } deriving (Ord, Eq)

instance Ix Symmetric where
 range ((Symmetric (x1,y1)), (Symmetric (x2,y2))) =
 map Symmetric [(x,y) | x &lt;- range (x1,x2), y &lt;- range (y1,y2), x &gt;= y]
 inRange (lo,hi) i = x &lt;= hix &amp;&amp; x &gt;= lox &amp;&amp; y &lt;= hiy &amp;&amp; y &gt;= loy &amp;&amp; x &gt;= y
 where
 (lox,loy) = pair lo
 (hix,hiy) = pair hi
 (x,y) = pair i
 index (lo,hi) i
 | inRange (lo,hi) i = (x-loy)+(sum$take(y-loy)[hix-lox, hix-lox-1..])
 | otherwise = error "Error in array index"
 where
 (lox,loy) = pair lo
 (hix,hiy) = pair hi
 (x,y) = pair i

sym x y 
 | x &lt; y = Symmetric (y,x)
 | otherwise = Symmetric (x,y)



*Main Data.Ix&gt; let a = listArray (sym 0 0, sym 6 6) [0..]
*Main Data.Ix&gt; a ! sym 3 2
14
*Main Data.Ix&gt; a ! sym 2 3
14
*Main Data.Ix&gt; a ! sym 2 2
13
*Main Data.Ix&gt; length $ elems a
28
*Main Data.Ix&gt; let b = listArray (sym 0 0, sym 19 19) [0..]
*Main Data.Ix&gt; length $ elems b
210
</code></pre>

Sorry for the vague question, but I hope for an experienced Haskeller this is a no-brainer.

I have to represent and manipulate symmetric matrices, so there are basically three different choices for the data type:

<ol>
<li>Complete matrix storing both the <code>(i,j)</code> and <code>(j,i)</code> element, although <code>m(i,j) = m(j,i)</code>

Data.Array (Int, Int) Int</li>
<li>A map, storing only elements <code>(i,j)</code> with <code>i &lt;= j</code> (upper triangular matrix)

Data.Map (Int, Int) Int</li>
<li>A vector indexed by <code>k</code>, storing the upper triangular matrix given some vector order <code>f(i,j) = k</code> 

Data.Array Int Int</li>
</ol>

Many operations are going to be necessary on the matrices, updating a single element, querying for rows and columns etc. However, they will mainly act as containers, no linear algebra operations (inversion, det, etc) will be required. 

Which one of the options would be the fastest one in general if the dimensionality of the matrices is going to be at around <code>20x20</code>? When I understand correctly, every update (with <code>(//)</code> in the case of array) requires full copies, so going from <code>20x20=400</code> elements to <code>20*21/2 = 210</code> elements in the cases 2. or 3. would make a lot of sense, but access is slower for case 2. and 3. needs conversion at some point.

Are there any guidelines? 

Btw: The 3rd option is not a really good one, as computing <code>f^-1</code> requires square roots.

Data.Map vs. Data.Array for symmetric matrices?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

不好意思问了个含糊的问题，但我希望对一个有经验的哈斯克勒来说，这是一个不需要思考的问题。我必须表示和操作对称矩阵，因此数据类型基本上有三种不同的选择：完成了存储(i,j)和(j,i)元素的矩阵，尽管m(i,j) = m(j,i)Data.Array (Int，Int) IntA映射，只存储带有i <= j (上三角矩阵...

问对称矩阵的Data.Map和Data.Array？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对称矩阵的Data.Map和Data.Array？EN