| products/Sources/formale Sprachen/GAP/pkg/matricesforhomalg/doc/chapB.html |
 |
<?xml version= "1.0" encoding= "UTF-8"?>
<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
< html xmlns= "http://www.w3.org/1999/xhtml" xml:lang= "en">
< head>
< title>GAP (MatricesForHomalg) - Appendix B: The Matrix Tool Operations</ title>
< meta http-equiv= "content-type" content= "text/html; charset=UTF-8" />
< meta name= "generator" content= "GAPDoc2HTML" />
< link rel= "stylesheet" type= "text/css" href= "manual.css" />
< script src= "manual.js" type= "text/javascript"></ script>
< script type= "text/javascript">overwriteStyle();</ script>
</ head>
< body class= "chapB" onload= "jscontent()">
< div class= "chlinktop">< span class= "chlink1">Goto Chapter: </ span>< a href= "chap0.html">Top</ a> < a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapA.html">A</a> <a href="chapB.html">B</a> <a href="chapC.html">C</a> <a href="chapD.html">D</a> <a href="chapE.html">E</a> <a href="chapF.html">F</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<div class="chlinkprevnexttop"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chapA.html">[Previous Chapter]</a> <a href="chapC.html">[Next Chapter]</a> </div>
<p id="mathjaxlink" class="pcenter"><a href="chapB_mj.html">[MathJax on]</a></p>
<p><a id="X7B2993CB7B012115" name="X7B2993CB7B012115"></a></p>
<div class="ChapSects"><a href="chapB.html#X7B2993CB7B012115">B <span class="Heading">The Matrix Tool Operations</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chapB.html#X7988F0AF7D87FD23">B.1 <span class="Heading">The Tool Operations <em>without</em> a Fallback Method</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7DBA33F083A317B5">B.1-1 InitialMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X84179BE87E7DCE76">B.1-2 InitialIdentityMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X785390E38396CAEB">B.1-3 ZeroMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X87BFF3567DEEBEF4">B.1-4 IdentityMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X85884C3178473521">B.1-5 Involution</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7AD2EEE680DF472B">B.1-6 TransposedMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7B6FC3267CD9EE9D">B.1-7 CertainRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X78EADFC67D17CF04">B.1-8 CertainColumns</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7DEB535782A3323E">B.1-9 UnionOfRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X86C345CE82AAB220">B.1-10 UnionOfRowsPair</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7DF5DB55836D13A7">B.1-11 UnionOfColumns</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X8092789C87E37020">B.1-12 UnionOfColumnsPair</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X86C5B86981FA1F9A">B.1-13 DiagMat</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X82202A6A7FAB7174">B.1-14 KroneckerMat</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X87E0747D7FEEAC76">B.1-15 DualKroneckerMat</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X828F8C7785EEC3D1">B.1-16 MulMat</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7B0B12F080A90039">B.1-17 AddMat</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7FE11AA27AE7D2D7">B.1-18 SubMat</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7D491D957E63C3A4">B.1-19 Compose</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X849BB912798A01EB">B.1-20 IsZeroMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7F4D7FAF821DA1C2">B.1-21 NumberRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7DFA534B7AFA2E17">B.1-22 NumberColumns</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X80A573257D7F2E1A">B.1-23 Determinant</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X8450E904787CBD35">B.1-24 CoefficientsWithGivenMonomials</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chapB.html#X7912E42C81296637">B.2 <span class="Heading">The Tool Operations with a Fallback Method</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7871FE5478BFC167">B.2-1 AreEqualMatrices</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X80C1856D82172268">B.2-2 IsIdentityMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7B6420E88418316B">B.2-3 IsDiagonalMatrix</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X872B70367F412945">B.2-4 ZeroRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7A469E6D7EA63BB6">B.2-5 ZeroColumns</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7BCBACDB79C96FBF">B.2-6 GetColumnIndependentUnitPositions</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X855C57B6822E7A98">B.2-7 GetRowIndependentUnitPositions</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X876495AA79063CDE">B.2-8 GetUnitPosition</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X7F40B57079CF80ED">B.2-9 PositionOfFirstNonZeroEntryPerRow</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chapB.html#X833B384278492266">B.2-10 PositionOfFirstNonZeroEntryPerColumn</a></span>
</div></div>
</div>
<h3>B <span class="Heading">The Matrix Tool Operations</span></h3>
<p>The functions listed below are components of the <code class="code">homalgTable</code> object stored in the ring. They are only indirectly accessible through standard methods that invoke them.</p>
<p><a id="X7988F0AF7D87FD23" name="X7988F0AF7D87FD23"></a></p>
<h4>B.1 <span class="Heading">The Tool Operations <em>without</em> a Fallback Method</span></h4>
<p>There are matrix methods for which <strong class="pkg">homalg</strong> needs a <code class="code">homalgTable</code> entry for non-internal rings, as it cannot provide a suitable fallback. Below is the list of these <code class="code">homalgTable</code> entries.</p>
<p><a id="X7DBA33F083A317B5" name="X7DBA33F083A317B5"></a></p>
<h5>B.1-1 InitialMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; InitialMatrix</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">InitialMatrix</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7EEAADA6807A5A45"><span class="RefLink">C.4-1</span></a>) resets the filter <code class="code">IsInitialMatrix</code> and returns <span class="SimpleMath">RP</span>!.<code class="code">InitialMatrix</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<p><a id="X84179BE87E7DCE76" name="X84179BE87E7DCE76"></a></p>
<h5>B.1-2 InitialIdentityMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; InitialIdentityMatrix</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">InitialIdentityMatrix</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7B619CA885024F0F"><span class="RefLink">C.4-2</span></a>) resets the filter <code class="code">IsInitialIdentityMatrix</code> and returns <span class="SimpleMath">RP</span>!.<code class="code">InitialIdentityMatrix</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<p><a id="X785390E38396CAEB" name="X785390E38396CAEB"></a></p>
<h5>B.1-3 ZeroMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; ZeroMatrix</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">ZeroMatrix</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7EADAA3180A84318"><span class="RefLink">C.4-3</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">ZeroMatrix</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<p><a id="X87BFF3567DEEBEF4" name="X87BFF3567DEEBEF4"></a></p>
<h5>B.1-4 IdentityMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; IdentityMatrix</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">IdentityMatrix</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X78CCA57B84E51834"><span class="RefLink">C.4-4</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">IdentityMatrix</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<p><a id="X85884C3178473521" name="X85884C3178473521"></a></p>
<h5>B.1-5 Involution</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; Involution</code>( <var class="Arg">M</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">Involution</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7928991E8768FA72"><span class="RefLink">C.4-7</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">Involution</code> applied to the content of the attribute <code class="code">EvalInvolution</code><span class="SimpleMath">( <var class="Arg">C</var> ) = <var class="Arg">M</var></span>.</p>
<p><a id="X7AD2EEE680DF472B" name="X7AD2EEE680DF472B"></a></p>
<h5>B.1-6 TransposedMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; TransposedMatrix</code>( <var class="Arg">M</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">TransposedMatrix</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X78D5359480EFC5AC"><span class="RefLink">C.4-8</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">TransposedMatrix</code> applied to the content of the attribute <code class="code">EvalTransposedMatrix</code><span class="SimpleMath">( <var class="Arg">C</var> ) = <var class="Arg">M</var></span>.</p>
<p><a id="X7B6FC3267CD9EE9D" name="X7B6FC3267CD9EE9D"></a></p>
<h5>B.1-7 CertainRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; CertainRows</code>( <var class="Arg">M</var>, <var class="Arg">plist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">CertainRows</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X852DCBD57A742FA5"><span class="RefLink">C.4-10</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">CertainRows</code> applied to the content of the attribute <code class="code">EvalCertainRows</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">M</var>, <var class="Arg">plist</var> ]</span>.</p>
<p><a id="X78EADFC67D17CF04" name="X78EADFC67D17CF04"></a></p>
<h5>B.1-8 CertainColumns</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; CertainColumns</code>( <var class="Arg">M</var>, <var class="Arg">plist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">CertainColumns</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X835F6F2E7D590F3D"><span class="RefLink">C.4-11</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">CertainColumns</code> applied to the content of the attribute <code class="code">EvalCertainColumns</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">M</var>, <var class="Arg">plist</var> ]</span>.</p>
<p><a id="X7DEB535782A3323E" name="X7DEB535782A3323E"></a></p>
<h5>B.1-9 UnionOfRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; UnionOfRows</code>( <var class="Arg">L</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">UnionOfRows</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7F35A61C8522A1B0"><span class="RefLink">C.4-12</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">UnionOfRows</code> applied to the content of the attribute <code class="code">EvalUnionOfRows</code><span class="SimpleMath">( <var class="Arg">C</var> ) = <var class="Arg">L</var></span>.</p>
<p><a id="X86C345CE82AAB220" name="X86C345CE82AAB220"></a></p>
<h5>B.1-10 UnionOfRowsPair</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; UnionOfRowsPair</code>( <var class="Arg">A</var>, <var class="Arg">B</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">UnionOfRowsPair</code> is bound and the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">UnionOfRows</code> is not bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7F35A61C8522A1B0"><span class="RefLink">C.4-12</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">UnionOfRowsPair</code> applied recursively to a balanced binary tree created from the content of the attribute <code class="code">EvalUnionOfRows</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<p><a id="X7DF5DB55836D13A7" name="X7DF5DB55836D13A7"></a></p>
<h5>B.1-11 UnionOfColumns</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; UnionOfColumns</code>( <var class="Arg">L</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">UnionOfColumns</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7EDE6095820F8128"><span class="RefLink">C.4-13</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">UnionOfColumns</code> applied to the content of the attribute <code class="code">EvalUnionOfColumns</code><span class="SimpleMath">( <var class="Arg">C</var> ) = <var class="Arg">L</var></span>.</p>
<p><a id="X8092789C87E37020" name="X8092789C87E37020"></a></p>
<h5>B.1-12 UnionOfColumnsPair</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; UnionOfColumnsPair</code>( <var class="Arg">A</var>, <var class="Arg">B</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">UnionOfColumnsPair</code> is bound and the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">UnionOfColumns</code> is not bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7EDE6095820F8128"><span class="RefLink">C.4-13</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">UnionOfColumnsPair</code> applied recursively to a balanced binary tree created from the content of the attribute <code class="code">EvalUnionOfRows</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<p><a id="X86C5B86981FA1F9A" name="X86C5B86981FA1F9A"></a></p>
<h5>B.1-13 DiagMat</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; DiagMat</code>( <var class="Arg">e</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">DiagMat</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7FD68F43831046B6"><span class="RefLink">C.4-14</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">DiagMat</code> applied to the content of the attribute <code class="code">EvalDiagMat</code><span class="SimpleMath">( <var class="Arg">C</var> ) = <var class="Arg">e</var></span>.</p>
<p><a id="X82202A6A7FAB7174" name="X82202A6A7FAB7174"></a></p>
<h5>B.1-14 KroneckerMat</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; KroneckerMat</code>( <var class="Arg">A</var>, <var class="Arg">B</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">KroneckerMat</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X84F45FB4854A079C"><span class="RefLink">C.4-15</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">KroneckerMat</code> applied to the content of the attribute <code class="code">EvalKroneckerMat</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">A</var>, <var class="Arg">B</var> ]</span>.</p>
<p><a id="X87E0747D7FEEAC76" name="X87E0747D7FEEAC76"></a></p>
<h5>B.1-15 DualKroneckerMat</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; DualKroneckerMat</code>( <var class="Arg">A</var>, <var class="Arg">B</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">DualKroneckerMat</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X78ADE5C879583E7B"><span class="RefLink">C.4-16</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">DualKroneckerMat</code> applied to the content of the attribute <code class="code">EvalDualKroneckerMat</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">A</var>, <var class="Arg">B</var> ]</span>.</p>
<p><a id="X828F8C7785EEC3D1" name="X828F8C7785EEC3D1"></a></p>
<h5>B.1-16 MulMat</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; MulMat</code>( <var class="Arg">a</var>, <var class="Arg">A</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">MulMat</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7B68797C7EA79B10"><span class="RefLink">C.4-17</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">MulMat</code> applied to the content of the attribute <code class="code">EvalMulMat</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">a</var>, <var class="Arg">A</var> ]</span>.</p>
<p><a id="X7B0B12F080A90039" name="X7B0B12F080A90039"></a></p>
<h5>B.1-17 AddMat</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; AddMat</code>( <var class="Arg">A</var>, <var class="Arg">B</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">AddMat</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X85971C16868BD83C"><span class="RefLink">C.4-18</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">AddMat</code> applied to the content of the attribute <code class="code">EvalAddMat</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">A</var>, <var class="Arg">B</var> ]</span>.</p>
<p><a id="X7FE11AA27AE7D2D7" name="X7FE11AA27AE7D2D7"></a></p>
<h5>B.1-18 SubMat</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; SubMat</code>( <var class="Arg">A</var>, <var class="Arg">B</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">SubMat</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X86F848318791595C"><span class="RefLink">C.4-19</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">SubMat</code> applied to the content of the attribute <code class="code">EvalSubMat</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">A</var>, <var class="Arg">B</var> ]</span>.</p>
<p><a id="X7D491D957E63C3A4" name="X7D491D957E63C3A4"></a></p>
<h5>B.1-19 Compose</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; Compose</code>( <var class="Arg">A</var>, <var class="Arg">B</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">Compose</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X7F7682FC86F602C2"><span class="RefLink">C.4-20</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">Compose</code> applied to the content of the attribute <code class="code">EvalCompose</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">A</var>, <var class="Arg">B</var> ]</span>.</p>
<p><a id="X849BB912798A01EB" name="X849BB912798A01EB"></a></p>
<h5>B.1-20 IsZeroMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; IsZeroMatrix</code>( <var class="Arg">M</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code> or <code class="code">false</code></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">IsZeroMatrix</code> is bound then the standard method for the property <code class="func">IsZero</code> (<a href="chap5.html#X858B5AF57D5BC90A"><span class="RefLink">5.3-1</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">IsZeroMatrix</code><span class="SimpleMath">( <var class="Arg">M</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( IsZero,
"for homalg matrices",
[ IsHomalgMatrix ],
function( M )
local R, RP;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.IsZeroMatrix) then
## CAUTION: the external system must be able
## to check zero modulo possible ring relations!
return RP!.IsZeroMatrix( M ); ## with this, \= can fall back to IsZero
fi;
#=====# the fallback method #=====#
## from the GAP4 documentation: ?Zero
## `ZeroSameMutability( <obj> )' is equivalent to `0 * <obj>'.
return M = 0 * M; ## hence, by default, IsZero falls back to \= (see below)
end );
</pre></div>
<p><a id="X7F4D7FAF821DA1C2" name="X7F4D7FAF821DA1C2"></a></p>
<h5>B.1-21 NumberRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; NumberRows</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a nonnegative integer</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">NumberRows</code> is bound then the standard method for the attribute <code class="func">NumberRows</code> (<a href="chap5.html#X7C72971F7D0CA3C8"><span class="RefLink">5.4-1</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">NumberRows</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( NumberRows,
"for homalg matrices",
[ IsHomalgMatrix ],
function( C )
local R, RP;
R := HomalgRing( C );
RP := homalgTable( R );
if IsBound(RP!.NumberRows) then
return RP!.NumberRows( C );
fi;
if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called NumberRows ",
"in the homalgTable of the non-internal ring\n" );
fi;
#=====# can only work for homalg internal matrices #=====#
return Length( Eval( C )!.matrix );
end );
</pre></div>
<p><a id="X7DFA534B7AFA2E17" name="X7DFA534B7AFA2E17"></a></p>
<h5>B.1-22 NumberColumns</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; NumberColumns</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a nonnegative integer</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">NumberColumns</code> is bound then the standard method for the attribute <code class="func">NumberColumns</code> (<a href="chap5.html#X847D45BF7F2BC67C"><span class="RefLink">5.4-2</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">NumberColumns</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( NumberColumns,
"for homalg matrices",
[ IsHomalgMatrix ],
function( C )
local R, RP;
R := HomalgRing( C );
RP := homalgTable( R );
if IsBound(RP!.NumberColumns) then
return RP!.NumberColumns( C );
fi;
if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called NumberColumns ",
"in the homalgTable of the non-internal ring\n" );
fi;
#=====# can only work for homalg internal matrices #=====#
return Length( Eval( C )!.matrix[ 1 ] );
end );
</pre></div>
<p><a id="X80A573257D7F2E1A" name="X80A573257D7F2E1A"></a></p>
<h5>B.1-23 Determinant</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; Determinant</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a ring element</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">Determinant</code> is bound then the standard method for the attribute <code class="func">DeterminantMat</code> (<a href="chap5.html#X83045F6F82C180E1"><span class="RefLink">5.4-3</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">Determinant</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( DeterminantMat,
"for homalg matrices",
[ IsHomalgMatrix ],
function( C )
local R, RP;
R := HomalgRing( C );
RP := homalgTable( R );
if NumberRows( C ) <> NumberColumns( C ) then
Error( "the matrix is not a square matrix\n" );
fi;
if IsEmptyMatrix( C ) then
return One( R );
elif IsZero( C ) then
return Zero( R );
fi;
if IsBound(RP!.Determinant) then
return RingElementConstructor( R )( RP!.Determinant( C ), R );
fi;
if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called Determinant ",
"in the homalgTable of the non-internal ring\n" );
fi;
#=====# can only work for homalg internal matrices #=====#
return Determinant( Eval( C )!.matrix );
end );
InstallMethod( Determinant,
"for homalg matrices",
[ IsHomalgMatrix ],
function( C )
return DeterminantMat( C );
end );
</pre></div>
<p><a id="X8450E904787CBD35" name="X8450E904787CBD35"></a></p>
<h5>B.1-24 CoefficientsWithGivenMonomials</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; CoefficientsWithGivenMonomials</code>( <var class="Arg">M</var>, <var class="Arg">monomials</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <code class="code">Eval</code> value of a <strong class="pkg">homalg</strong> matrix <var class="Arg">C</var></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">CoefficientsWithGivenMonomials</code> is bound then the method <code class="func">Eval</code> (<a href="chapC.html#X848FE4F07BAF89DB"><span class="RefLink">C.4-21</span></a>) returns <span class="SimpleMath">RP</span>!.<code class="code">CoefficientsWithGivenMonomials</code> applied to the content of the attribute <code class="code">EvalCoefficientsWithGivenMonomials</code><span class="SimpleMath">( <var class="Arg">C</var> ) = [ <var class="Arg">M</var>, <var class="Arg">monomials</var> ]</span>.</p>
<p><a id="X7912E42C81296637" name="X7912E42C81296637"></a></p>
<h4>B.2 <span class="Heading">The Tool Operations with a Fallback Method</span></h4>
<p>These are the methods for which it is recommended for performance reasons to have a <code class="code">homalgTable</code> entry for non-internal rings. <strong class="pkg">homalg</strong> only provides a generic fallback method.</p>
<p><a id="X7871FE5478BFC167" name="X7871FE5478BFC167"></a></p>
<h5>B.2-1 AreEqualMatrices</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; AreEqualMatrices</code>( <var class="Arg">M1</var>, <var class="Arg">M2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code> or <code class="code">false</code></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M1</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">AreEqualMatrices</code> is bound then the standard method for the operation <code class="func">\=</code> (<a href="chap5.html#X7E2074A77AFF518A"><span class="RefLink">5.5-23</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">AreEqualMatrices</code><span class="SimpleMath">( <var class="Arg">M1</var>, <var class="Arg">M2</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( \=,
"for homalg comparable matrices",
[ IsHomalgMatrix, IsHomalgMatrix ],
function( M1, M2 )
local R, RP, are_equal;
## do not touch mutable matrices
if not ( IsMutable( M1 ) or IsMutable( M2 ) ) then
if IsBound( M1!.AreEqual ) then
are_equal := _ElmWPObj_ForHomalg( M1!.AreEqual, M2, fail );
if are_equal <> fail then
return are_equal;
fi;
else
M1!.AreEqual :=
ContainerForWeakPointers(
TheTypeContainerForWeakPointersOnComputedValues,
[ "operation", "AreEqual" ] );
fi;
if IsBound( M2!.AreEqual ) then
are_equal := _ElmWPObj_ForHomalg( M2!.AreEqual, M1, fail );
if are_equal <> fail then
return are_equal;
fi;
fi;
## do not store things symmetrically below to ``save'' memory
fi;
R := HomalgRing( M1 );
RP := homalgTable( R );
if IsBound(RP!.AreEqualMatrices) then
## CAUTION: the external system must be able to check equality
## modulo possible ring relations (known to the external system)!
are_equal := RP!.AreEqualMatrices( M1, M2 );
elif IsBound(RP!.Equal) then
## CAUTION: the external system must be able to check equality
## modulo possible ring relations (known to the external system)!
are_equal := RP!.Equal( M1, M2 );
elif IsBound(RP!.IsZeroMatrix) then ## ensuring this avoids infinite loops
are_equal := IsZero( M1 - M2 );
fi;
if IsBound( are_equal ) then
## do not touch mutable matrices
if not ( IsMutable( M1 ) or IsMutable( M2 ) ) then
if are_equal then
MatchPropertiesAndAttributes( M1, M2,
LIMAT.intrinsic_properties,
LIMAT.intrinsic_attributes,
LIMAT.intrinsic_components,
LIMAT.intrinsic_attributes_do_not_check_their_equality
);
fi;
## do not store things symmetrically to ``save'' memory
_AddTwoElmWPObj_ForHomalg( M1!.AreEqual, M2, are_equal );
fi;
return are_equal;
fi;
TryNextMethod( );
end );
</pre></div>
<p><a id="X80C1856D82172268" name="X80C1856D82172268"></a></p>
<h5>B.2-2 IsIdentityMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; IsIdentityMatrix</code>( <var class="Arg">M</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code> or <code class="code">false</code></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">IsIdentityMatrix</code> is bound then the standard method for the property <code class="func">IsOne</code> (<a href="chap5.html#X814D78347858EC13"><span class="RefLink">5.3-2</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">IsIdentityMatrix</code><span class="SimpleMath">( <var class="Arg">M</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( IsOne,
"for homalg matrices",
[ IsHomalgMatrix ],
function( M )
local R, RP;
if NumberRows( M ) <> NumberColumns( M ) then
return false;
fi;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.IsIdentityMatrix) then
return RP!.IsIdentityMatrix( M );
fi;
#=====# the fallback method #=====#
return M = HomalgIdentityMatrix( NumberRows( M ), HomalgRing( M ) );
end );
</pre></div>
<p><a id="X7B6420E88418316B" name="X7B6420E88418316B"></a></p>
<h5>B.2-3 IsDiagonalMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; IsDiagonalMatrix</code>( <var class="Arg">M</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code> or <code class="code">false</code></p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">IsDiagonalMatrix</code> is bound then the standard method for the property <code class="func">IsDiagonalMatrix</code> (<a href="chap5.html#X7EEC8E768178696E"><span class="RefLink">5.3-13</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">IsDiagonalMatrix</code><span class="SimpleMath">( <var class="Arg">M</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( IsDiagonalMatrix,
"for homalg matrices",
[ IsHomalgMatrix ],
function( M )
local R, RP, diag;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.IsDiagonalMatrix) then
return RP!.IsDiagonalMatrix( M );
fi;
#=====# the fallback method #=====#
diag := DiagonalEntries( M );
return M = HomalgDiagonalMatrix( diag, NumberRows( M ), NumberColumns( M ), R );
end );
</pre></div>
<p><a id="X872B70367F412945" name="X872B70367F412945"></a></p>
<h5>B.2-4 ZeroRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; ZeroRows</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a (possibly empty) list of positive integers</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">ZeroRows</code> is bound then the standard method of the attribute <code class="func">ZeroRows</code> (<a href="chap5.html#X828225E0857B1FDA"><span class="RefLink">5.4-4</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">ZeroRows</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( ZeroRows,
"for homalg matrices",
[ IsHomalgMatrix ],
function( C )
local R, RP, z;
R := HomalgRing( C );
RP := homalgTable( R );
if IsBound(RP!.ZeroRows) then
return RP!.ZeroRows( C );
fi;
#=====# the fallback method #=====#
z := HomalgZeroMatrix( 1, NumberColumns( C ), R );
return Filtered( [ 1 .. NumberRows( C ) ], a -> CertainRows( C, [ a ] ) = z );
end );
</pre></div>
<p><a id="X7A469E6D7EA63BB6" name="X7A469E6D7EA63BB6"></a></p>
<h5>B.2-5 ZeroColumns</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; ZeroColumns</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a (possibly empty) list of positive integers</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">C</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">ZeroColumns</code> is bound then the standard method of the attribute <code class="func">ZeroColumns</code> (<a href="chap5.html#X870D761F7AB96D12"><span class="RefLink">5.4-5</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">ZeroColumns</code><span class="SimpleMath">( <var class="Arg">C</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( ZeroColumns,
"for homalg matrices",
[ IsHomalgMatrix ],
function( C )
local R, RP, z;
R := HomalgRing( C );
RP := homalgTable( R );
if IsBound(RP!.ZeroColumns) then
return RP!.ZeroColumns( C );
fi;
#=====# the fallback method #=====#
z := HomalgZeroMatrix( NumberRows( C ), 1, R );
return Filtered( [ 1 .. NumberColumns( C ) ], a -> CertainColumns( C, [ a ] ) = z );
end );
</pre></div>
<p><a id="X7BCBACDB79C96FBF" name="X7BCBACDB79C96FBF"></a></p>
<h5>B.2-6 GetColumnIndependentUnitPositions</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; GetColumnIndependentUnitPositions</code>( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a (possibly empty) list of pairs of positive integers</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">GetColumnIndependentUnitPositions</code> is bound then the standard method of the operation <code class="func">GetColumnIndependentUnitPositions</code> (<a href="chap5.html#X85887BBB86F0A08B"><span class="RefLink">5.5-24</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">GetColumnIndependentUnitPositions</code><span class="SimpleMath">( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( GetColumnIndependentUnitPositions,
"for homalg matrices",
[ IsHomalgMatrix, IsHomogeneousList ],
function( M, poslist )
local cache, R, RP, rest, pos, i, j, k;
if IsBound( M!.GetColumnIndependentUnitPositions ) then
cache := M!.GetColumnIndependentUnitPositions;
if IsBound( cache.(String( poslist )) ) then
return cache.(String( poslist ));
fi;
else
cache := rec( );
M!.GetColumnIndependentUnitPositions := cache;
fi;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.GetColumnIndependentUnitPositions) then
pos := RP!.GetColumnIndependentUnitPositions( M, poslist );
if pos <> [ ] then
SetIsZero( M, false );
fi;
cache.(String( poslist )) := pos;
return pos;
fi;
#=====# the fallback method #=====#
rest := [ 1 .. NumberColumns( M ) ];
pos := [ ];
for i in [ 1 .. NumberRows( M ) ] do
for k in Reversed( rest ) do
if not [ i, k ] in poslist and
IsUnit( R, M[ i, k ] ) then
Add( pos, [ i, k ] );
rest := Filtered( rest,
a -> IsZero( M[ i, a ] ) );
break;
fi;
od;
od;
if pos <> [ ] then
SetIsZero( M, false );
fi;
cache.(String( poslist )) := pos;
return pos;
end );
</pre></div>
<p><a id="X855C57B6822E7A98" name="X855C57B6822E7A98"></a></p>
<h5>B.2-7 GetRowIndependentUnitPositions</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; GetRowIndependentUnitPositions</code>( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a (possibly empty) list of pairs of positive integers</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">GetRowIndependentUnitPositions</code> is bound then the standard method of the operation <code class="func">GetRowIndependentUnitPositions</code> (<a href="chap5.html#X824AB44184DD63B0"><span class="RefLink">5.5-25</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">GetRowIndependentUnitPositions</code><span class="SimpleMath">( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( GetRowIndependentUnitPositions,
"for homalg matrices",
[ IsHomalgMatrix, IsHomogeneousList ],
function( M, poslist )
local cache, R, RP, rest, pos, j, i, k;
if IsBound( M!.GetRowIndependentUnitPositions ) then
cache := M!.GetRowIndependentUnitPositions;
if IsBound( cache.(String( poslist )) ) then
return cache.(String( poslist ));
fi;
else
cache := rec( );
M!.GetRowIndependentUnitPositions := cache;
fi;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.GetRowIndependentUnitPositions) then
pos := RP!.GetRowIndependentUnitPositions( M, poslist );
if pos <> [ ] then
SetIsZero( M, false );
fi;
cache.( String( poslist ) ) := pos;
return pos;
fi;
#=====# the fallback method #=====#
rest := [ 1 .. NumberRows( M ) ];
pos := [ ];
for j in [ 1 .. NumberColumns( M ) ] do
for k in Reversed( rest ) do
if not [ j, k ] in poslist and
IsUnit( R, M[ k, j ] ) then
Add( pos, [ j, k ] );
rest := Filtered( rest,
a -> IsZero( M[ a, j ] ) );
break;
fi;
od;
od;
if pos <> [ ] then
SetIsZero( M, false );
fi;
cache.( String( poslist ) ) := pos;
return pos;
end );
</pre></div>
<p><a id="X876495AA79063CDE" name="X876495AA79063CDE"></a></p>
<h5>B.2-8 GetUnitPosition</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; GetUnitPosition</code>( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a (possibly empty) list of pairs of positive integers</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">GetUnitPosition</code> is bound then the standard method of the operation <code class="func">GetUnitPosition</code> (<a href="chap5.html#X7A1969A17979FC49"><span class="RefLink">5.5-26</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">GetUnitPosition</code><span class="SimpleMath">( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( GetUnitPosition,
"for homalg matrices",
[ IsHomalgMatrix, IsHomogeneousList ],
function( M, poslist )
local R, RP, pos, m, n, i, j;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.GetUnitPosition) then
pos := RP!.GetUnitPosition( M, poslist );
if IsList( pos ) and IsPosInt( pos[1] ) and IsPosInt( pos[2] ) then
SetIsZero( M, false );
fi;
return pos;
fi;
#=====# the fallback method #=====#
m := NumberRows( M );
n := NumberColumns( M );
for i in [ 1 .. m ] do
for j in [ 1 .. n ] do
if not [ i, j ] in poslist and not j in poslist and
IsUnit( R, M[ i, j ] ) then
SetIsZero( M, false );
return [ i, j ];
fi;
od;
od;
return fail;
end );
</pre></div>
<p><a id="X7F40B57079CF80ED" name="X7F40B57079CF80ED"></a></p>
<h5>B.2-9 PositionOfFirstNonZeroEntryPerRow</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; PositionOfFirstNonZeroEntryPerRow</code>( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a list of nonnegative integers</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">PositionOfFirstNonZeroEntryPerRow</code> is bound then the standard method of the attribute <code class="func">PositionOfFirstNonZeroEntryPerRow</code> (<a href="chap5.html#X7B7A073D7E1FAEA4"><span class="RefLink">5.4-8</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">PositionOfFirstNonZeroEntryPerRow</code><span class="SimpleMath">( <var class="Arg">M</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( PositionOfFirstNonZeroEntryPerRow,
"for homalg matrices",
[ IsHomalgMatrix ],
function( M )
local R, RP, pos, entries, r, c, i, k, j;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.PositionOfFirstNonZeroEntryPerRow) then
return RP!.PositionOfFirstNonZeroEntryPerRow( M );
elif IsBound(RP!.PositionOfFirstNonZeroEntryPerColumn) then
return PositionOfFirstNonZeroEntryPerColumn( Involution( M ) );
fi;
#=====# the fallback method #=====#
entries := EntriesOfHomalgMatrix( M );
r := NumberRows( M );
c := NumberColumns( M );
pos := ListWithIdenticalEntries( r, 0 );
for i in [ 1 .. r ] do
k := (i - 1) * c;
for j in [ 1 .. c ] do
if not IsZero( entries[k + j] ) then
pos[i] := j;
break;
fi;
od;
od;
return pos;
end );
</pre></div>
<p><a id="X833B384278492266" name="X833B384278492266"></a></p>
<h5>B.2-10 PositionOfFirstNonZeroEntryPerColumn</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#an style='color: green'>8227; PositionOfFirstNonZeroEntryPerColumn</code>( <var class="Arg">M</var>, <var class="Arg">poslist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a list of nonnegative integers</p>
<p>Let <span class="SimpleMath">R :=</span> <code class="code">HomalgRing</code><span class="SimpleMath">( <var class="Arg">M</var> )</span> and <span class="SimpleMath">RP :=</span> <code class="code">homalgTable</code><span class="SimpleMath">( R )</span>. If the <code class="code">homalgTable</code> component <span class="SimpleMath">RP</span>!.<code class="code">PositionOfFirstNonZeroEntryPerColumn</code> is bound then the standard method of the attribute <code class="func">PositionOfFirstNonZeroEntryPerColumn</code> (<a href="chap5.html#X83B389A97A703E42"><span class="RefLink">5.4-9</span></a>) shown below returns <span class="SimpleMath">RP</span>!.<code class="code">PositionOfFirstNonZeroEntryPerColumn</code><span class="SimpleMath">( <var class="Arg">M</var> )</span>.</p>
<div class="example"><pre>
InstallMethod( PositionOfFirstNonZeroEntryPerColumn,
"for homalg matrices",
[ IsHomalgMatrix ],
function( M )
local R, RP, pos, entries, r, c, j, i, k;
R := HomalgRing( M );
RP := homalgTable( R );
if IsBound(RP!.PositionOfFirstNonZeroEntryPerColumn) then
return RP!.PositionOfFirstNonZeroEntryPerColumn( M );
elif IsBound(RP!.PositionOfFirstNonZeroEntryPerRow) then
return PositionOfFirstNonZeroEntryPerRow( Involution( M ) );
fi;
#=====# the fallback method #=====#
entries := EntriesOfHomalgMatrix( M );
r := NumberRows( M );
c := NumberColumns( M );
pos := ListWithIdenticalEntries( c, 0 );
for j in [ 1 .. c ] do
for i in [ 1 .. r ] do
k := (i - 1) * c;
if not IsZero( entries[k + j] ) then
pos[j] := i;
break;
fi;
od;
od;
return pos;
end );
</pre></div>
<div class="chlinkprevnextbot"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chapA.html">[Previous Chapter]</a> <a href="chapC.html">[Next Chapter]</a> </div>
<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapA.html">A</a> <a href="chapB.html">B</a> <a href="chapC.html">C</a> <a href="chapD.html">D</a> <a href="chapE.html">E</a> <a href="chapF.html">F</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<hr />
<p class="foot">generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>
¤ Dauer der Verarbeitung: 0.14 Sekunden
(vorverarbeitet am 2026-11-04)
¤
*© Formatika GbR, Deutschland
|
|
