Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/C/Linux/tools/workqueue/   (Open Source Betriebssystem Version 6.17.9©)  Datei vom 24.10.2025 mit Größe 8 kB image not shown  

Quelle  chap10_mj.html   Sprache: HTML

 
 products/sources/formale Sprachen/GAP/pkg/toolsforhomalg/doc/chap10_mj.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>
<script type="text/javascript"
  src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (ToolsForHomalg) - Chapter 10: Z-functions</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="chap10"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a>  <a href="chap1_mj.html">1</a>  <a href="chap2_mj.html">2</a>  <a href="chap3_mj.html">3</a>  <a href="chap4_mj.html">4</a>  <a href="chap5_mj.html">5</a>  <a href="chap6_mj.html">6</a>  <a href="chap7_mj.html">7</a>  <a href="chap8_mj.html">8</a>  <a href="chap9_mj.html">9</a>  <a href="chap10_mj.html">10</a>  <a href="chapInd_mj.html">Ind</a>  </div>

<div class="chlinkprevnexttop"> <a href="chap0_mj.html">[Top of Book]</a>   <a href="chap0_mj.html#contents">[Contents]</a>    <a href="chap9_mj.html">[Previous Chapter]</a>    <a href="chapInd_mj.html">[Next Chapter]</a>   </div>

<p id="mathjaxlink" class="pcenter"><a href="chap10.html">[MathJax off]</a></p>
<p><a id="X7BE235988693C72F" name="X7BE235988693C72F"></a></p>
<div class="ChapSects"><a href="chap10_mj.html#X7BE235988693C72F">10 <span class="Heading">Z-functions</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap10_mj.html#X85BDA2257D22C617">10.1 <span class="Heading">Gap categories for Z functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X824F514F847A353D">10.1-1 IsZFunction</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7F33D8E781560FA8">10.1-2 IsZFunctionWithInductiveSides</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap10_mj.html#X8416D8F37C19C23D">10.2 <span class="Heading">Creating Z-functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7F11AE5C829E0465">10.2-1 VoidZFunction</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7D65928287AA2E78">10.2-2 AsZFunction</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X860B41867880891C">10.2-3 UnderlyingFunction</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X78F26197785091E3">10.2-4 ZFunctionValue</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X79F5AA977A75B664"><code>10.2-5 <span>\</span>[<span>\</span>]</code></a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X867DAC087866CD8C">10.2-6 ZFunctionWithInductiveSides</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7F50565B78308CB0">10.2-7 UpperFunction</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X8553572B7B5E58D9">10.2-8 StableUpperValue</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X846C56B882566639">10.2-9 IndexOfStableUpperValue</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X839E578D86B98DFD">10.2-10 SetStableUpperValue</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7C607DDE786591AC">10.2-11 StableLowerValue</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7D5F7C4D80091041">10.2-12 IndexOfStableLowerValue</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7E01C0927F9B5AC7">10.2-13 SetStableLowerValue</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X863225F9798BD2CC">10.2-14 Reflection</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X80EB63EC828CE582">10.2-15 ApplyShift</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X8308ACDA78E96FC5">10.2-16 ApplyMap</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7AC919EC8734B869">10.2-17 ApplyMap</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7E943C6E7B5784CD">10.2-18 BaseZFunctions</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X7A7795C883285A22">10.2-19 AppliedMap</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X854A6DE682EAADB3">10.2-20 CombineZFunctions</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap10_mj.html#X83D1892185F38BDA">10.2-21 Replace</a></span>
</div></div>
</div>

<h3>10 <span class="Heading">Z-functions</span></h3>

<p><a id="X85BDA2257D22C617" name="X85BDA2257D22C617"></a></p>

<h4>10.1 <span class="Heading">Gap categories for Z functions</span></h4>

<p>A <span class="SimpleMath">\(\mathbb{Z}\)</span>-function is an enumerated collection of objects in which repetitions are allowed and order does matter. The reason behind calling it a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function rather than simply a sequence, is to avoid possible conflicts with other packages that use the terms <em>Sequence</em> and <em>IsSequence</em>.</p>

<p><a id="X824F514F847A353D" name="X824F514F847A353D"></a></p>

<h5>10.1-1 IsZFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsZFunction</code>( <var class="Arg">arg</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>Gap-categories of <span class="SimpleMath">\(\mathbb{Z}\)</span>-functions</p>

<p><a id="X7F33D8E781560FA8" name="X7F33D8E781560FA8"></a></p>

<h5>10.1-2 IsZFunctionWithInductiveSides</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsZFunctionWithInductiveSides</code>( <var class="Arg">arg</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>Gap-categories of inductive <span class="SimpleMath">\(\mathbb{Z}\)</span>-functions</p>

<p><a id="X8416D8F37C19C23D" name="X8416D8F37C19C23D"></a></p>

<h4>10.2 <span class="Heading">Creating Z-functions</span></h4>

<p><a id="X7F11AE5C829E0465" name="X7F11AE5C829E0465"></a></p>

<h5>10.2-1 VoidZFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ VoidZFunction</code>( <var class="Arg">func</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: an integer</p>

<p>The global function has no arguments and the output is an empty <span class="SimpleMath">\(\mathbb{Z}\)</span>-function. That means, it can not be evaluated yet.</p>

<p><a id="X7D65928287AA2E78" name="X7D65928287AA2E78"></a></p>

<h5>10.2-2 AsZFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AsZFunction</code>( <var class="Arg">func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The argument is a function <var class="Arg">func</var> that can be applied on integers. The output is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <code class="code">z_func</code>. We call <var class="Arg">func</var> the <code class="code">UnderlyingFunction</code> of <code class="code">z_func</code>.</p>

<p><a id="X860B41867880891C" name="X860B41867880891C"></a></p>

<h5>10.2-3 UnderlyingFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ UnderlyingFunction</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The argument is a <var class="Arg">z_func</var>. The output is its <code class="code">UnderlyingFunction</code> function. I.e., the function that will be applied on index <code class="code">i</code> whenever we call <var class="Arg">z_func</var>[<code class="code">i</code>].</p>

<p><a id="X78F26197785091E3" name="X78F26197785091E3"></a></p>

<h5>10.2-4 ZFunctionValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ZFunctionValue</code>( <var class="Arg">z_func</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a Gap object</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var> and an integer <var class="Arg">i</var>. The output is <var class="Arg">z_func</var>[<var class="Arg">i</var>].</p>

<p><a id="X79F5AA977A75B664" name="X79F5AA977A75B664"></a></p>

<h5><code>10.2-5 <span>\</span>[<span>\</span>]</code></h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ <span>\</span>[<span>\</span>]</code>( <var class="Arg">z_func</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a Gap object</p>

<p>The method delegates to <code class="code">ZFunctionValue</code>.</p>

<p><a id="X867DAC087866CD8C" name="X867DAC087866CD8C"></a></p>

<h5>10.2-6 ZFunctionWithInductiveSides</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ZFunctionWithInductiveSides</code>( <var class="Arg">n</var>, <var class="Arg">val_n</var>, <var class="Arg">lower_func</var>, <var class="Arg">upper_func</var>, <var class="Arg">compare_func</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function with inductive sides</p>

<p>The arguments are an integer <var class="Arg">n</var>, a Gap object <var class="Arg">val_n</var>, a function <var class="Arg">lower_func</var>, a function <var class="Arg">upper_func</var> and a function <var class="Arg">compare_func</var>. The output is the <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <code class="code">z_func</code> defined as follows: <code class="code">z_func</code>[<code class="code">i</code>] is equal to <var class="Arg">lower_func</var>(<code class="code">z_func</code>[<code class="code">i+1</code>]) if <code class="code">i</code><code class="code"><</code><var class="Arg">n</var>; and is equal to <var class="Arg">val_n</var> if <code class="code">i</code>=<var class="Arg">n</var>; and is equal to <var class="Arg">upper_func</var>(<code class="code">z_func</code>[<code class="code">i-1</code>]) otherwise. At each call, the method compares the computed value to the previous or next value via the function <var class="Arg">compare_func</var>; and in the affermative case, the method sets a upper or lower stable values.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">f := function (i) Print( "Current i is ", i, "\n" ); return i^2; end;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">seq := AsZFunction( f );</span>
<ZFunction>
<span class="GAPprompt">gap></span> <span class="GAPinput">seq[ 0 ];</span>
Current i is 0
0
<span class="GAPprompt">gap></span> <span class="GAPinput">seq[ 0 ];</span>
0
<span class="GAPprompt">gap></span> <span class="GAPinput">upper_func := function ( a )</span>
<span class="GAPprompt">></span> <span class="GAPinput">  if a[ 2 ] <> 0 then return [ a[ 2 ], a[ 1 ] mod a[ 2 ] ]; fi; return a; end;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">lower_func := IdFunc;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gcd_seq := ZFunctionWithInductiveSides( 0, [ 111, 259 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput">              lower_func, upper_func, \= );</span>
<ZFunction>
<span class="GAPprompt">gap></span> <span class="GAPinput">HasStableLowerValue( gcd_seq );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">gcd_seq[ -1 ];</span>
[ 111, 259 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">HasStableLowerValue( gcd_seq );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">StableLowerValue( gcd_seq );</span>
[ 111, 259 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IndexOfStableLowerValue( gcd_seq );</span>
0
<span class="GAPprompt">gap></span> <span class="GAPinput">gcd_seq[ 0 ];</span>
[ 111, 259 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">gcd_seq[ 1 ];</span>
[ 259, 111 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">gcd_seq[ 2 ];</span>
[ 111, 37 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">gcd_seq[ 3 ];</span>
[ 37, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">HasStableUpperValue( gcd_seq );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">gcd_seq[ 4 ];</span>
[ 37, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">HasStableUpperValue( gcd_seq );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">StableUpperValue( gcd_seq );</span>
[ 37, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IndexOfStableUpperValue( gcd_seq );</span>
3
<span class="GAPprompt">gap></span> <span class="GAPinput">sum := ApplyMap( gcd_seq, Sum );</span>
<ZFunction>
<span class="GAPprompt">gap></span> <span class="GAPinput">sum[ 0 ];</span>
370
<span class="GAPprompt">gap></span> <span class="GAPinput">sum[ 100 ];</span>
37
<span class="GAPprompt">gap></span> <span class="GAPinput">c := CombineZFunctions( [ gcd_seq, sum ] );</span>
<ZFunction>
<span class="GAPprompt">gap></span> <span class="GAPinput">c[ 0 ];</span>
[ [ 111, 259 ], 370 ]
</pre></div>

<p><a id="X7F50565B78308CB0" name="X7F50565B78308CB0"></a></p>

<h5>10.2-7 UpperFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ UpperFunction</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LowerFunction</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StartingIndex</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StartingValue</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CompareFunction</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a function</p>

<p>They are the attributes that define a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function with inductive sides.</p>

<p><a id="X8553572B7B5E58D9" name="X8553572B7B5E58D9"></a></p>

<h5>10.2-8 StableUpperValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StableUpperValue</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a Gap object</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var>. We say that <var class="Arg">z_func</var> has a stable upper value <code class="code">val</code>, if there is an index <code class="code">n</code> such that <var class="Arg">z_func</var>[<code class="code">i</code>] is equal to <code class="code">val</code> for all indices <code class="code">i</code>'s greater or equal to n. In that case, the output is the value val.



<p><a id="X846C56B882566639" name="X846C56B882566639"></a></p>

<h5>10.2-9 IndexOfStableUpperValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IndexOfStableUpperValue</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: an integer</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var> with a stable upper value <code class="code">val</code>. The output is some index where <var class="Arg">z_func</var> starts to take values equal to <code class="code">val</code>.</p>

<p><a id="X839E578D86B98DFD" name="X839E578D86B98DFD"></a></p>

<h5>10.2-10 SetStableUpperValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetStableUpperValue</code>( <var class="Arg">z_func</var>, <var class="Arg">n</var>, <var class="Arg">val</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: nothing</p>

<p>The arguments are a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var>, an integer <var class="Arg">n</var> and an object <var class="Arg">val</var>. The operation sets <var class="Arg">val</var> as a stable upper value for <var class="Arg">z_func</var> at the index <var class="Arg">n</var>.</p>

<p><a id="X7C607DDE786591AC" name="X7C607DDE786591AC"></a></p>

<h5>10.2-11 StableLowerValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StableLowerValue</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a Gap object</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var>. We say that <var class="Arg">z_func</var> has a stable lower value <code class="code">val</code>, if there is an index <code class="code">n</code> such that <var class="Arg">z_func</var>[<code class="code">i</code>] is equal to <code class="code">val</code> for all indices <code class="code">i</code>'s less or equal to n. In that case, the output is the value val.



<p><a id="X7D5F7C4D80091041" name="X7D5F7C4D80091041"></a></p>

<h5>10.2-12 IndexOfStableLowerValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IndexOfStableLowerValue</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: an integer</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var> with a stable lower value <code class="code">val</code>. The output is some index where <var class="Arg">z_func</var> starts to take values equal to <code class="code">val</code>.</p>

<p><a id="X7E01C0927F9B5AC7" name="X7E01C0927F9B5AC7"></a></p>

<h5>10.2-13 SetStableLowerValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetStableLowerValue</code>( <var class="Arg">z_func</var>, <var class="Arg">n</var>, <var class="Arg">val</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: nothing</p>

<p>The arguments are a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var>, an integer <var class="Arg">n</var> and an object <var class="Arg">val</var>. The operation sets <var class="Arg">val</var> as a stable lower value for <var class="Arg">z_func</var> at the index <var class="Arg">n</var>.</p>

<p><a id="X863225F9798BD2CC" name="X863225F9798BD2CC"></a></p>

<h5>10.2-14 Reflection</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Reflection</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var>. The output is another <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <code class="code">ref_z_func</code> such that <code class="code">ref_z_func</code>[<code class="code">i</code>] is equal to <var class="Arg">z_func</var>[<code class="code">-i</code>] for all <code class="code">i</code>'s in \(\mathbb{Z}\).



<p><a id="X80EB63EC828CE582" name="X80EB63EC828CE582"></a></p>

<h5>10.2-15 ApplyShift</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ApplyShift</code>( <var class="Arg">z_func</var>, <var class="Arg">n</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var> and an integer <var class="Arg">n</var>. The output is another <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <code class="code">m</code> such that <code class="code">m</code>[<code class="code">i</code>] is equal to <var class="Arg">z_func</var>[<code class="code">n+i</code>].</p>

<p><a id="X8308ACDA78E96FC5" name="X8308ACDA78E96FC5"></a></p>

<h5>10.2-16 ApplyMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ApplyMap</code>( <var class="Arg">z_func</var>, <var class="Arg">F</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The arguments are a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var> and a function <var class="Arg">F</var> that can be applied on one argument. The output is another <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <code class="code">m</code> such that <code class="code">m</code>[<code class="code">i</code>] is equal to <var class="Arg">F</var>(<var class="Arg">z_func</var>[<code class="code">i</code>]).</p>

<p><a id="X7AC919EC8734B869" name="X7AC919EC8734B869"></a></p>

<h5>10.2-17 ApplyMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ApplyMap</code>( <var class="Arg">L</var>, <var class="Arg">F</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The arguments are a list of <span class="SimpleMath">\(\mathbb{Z}\)</span>-functions <var class="Arg">L</var> and a function <var class="Arg">F</var> with <code class="code">Length</code>(<var class="Arg">L</var>) arguments. The output is another <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <code class="code">m</code> such that <code class="code">m</code>[<code class="code">i</code>] is equal to <var class="Arg">F</var>(<var class="Arg">L</var>[1][<code class="code">i</code>],..., <var class="Arg">L</var>[<code class="code">Length</code>(<var class="Arg">L</var>)][<code class="code">i</code>]). We call the list <var class="Arg">L</var> the <code class="code">BaseZFunctions</code> of <code class="code">m</code> and <var class="Arg">F</var> the <code class="code">AppliedMap</code>.</p>

<p><a id="X7E943C6E7B5784CD" name="X7E943C6E7B5784CD"></a></p>

<h5>10.2-18 BaseZFunctions</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BaseZFunctions</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of <span class="SimpleMath">\(\mathbb{Z}\)</span>-functions</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var> that has been defined by applying a map <code class="code">F</code> on a list <code class="code">L</code> of <span class="SimpleMath">\(\mathbb{Z}\)</span>-functions. The output is the list <code class="code">L</code>.</p>

<p><a id="X7A7795C883285A22" name="X7A7795C883285A22"></a></p>

<h5>10.2-19 AppliedMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AppliedMap</code>( <var class="Arg">z_func</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var> that has been defined by applying a map <code class="code">F</code> on a list <code class="code">L</code> of <span class="SimpleMath">\(\mathbb{Z}\)</span>-functions. The output is the function <code class="code">F</code>.</p>

<p><a id="X854A6DE682EAADB3" name="X854A6DE682EAADB3"></a></p>

<h5>10.2-20 CombineZFunctions</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CombineZFunctions</code>( <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The argument is a dense list <var class="Arg">L</var> of <span class="SimpleMath">\(\mathbb{Z}\)</span>-functions. The output is another <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <code class="code">m</code> such that <code class="code">m</code>[<code class="code">i</code>] is equal to [<var class="Arg">L</var>[1][<code class="code">i</code>],..., <var class="Arg">L</var>[<code class="code">Length</code>(<var class="Arg">L</var>)][<code class="code">i</code>]] for all indices <code class="code">i</code>'s in \(\mathbb{Z}\).



<p><a id="X83D1892185F38BDA" name="X83D1892185F38BDA"></a></p>

<h5>10.2-21 Replace</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Replace</code>( <var class="Arg">z_func</var>, <var class="Arg">n</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function</p>

<p>The argument is a <span class="SimpleMath">\(\mathbb{Z}\)</span>-function <var class="Arg">z_func</var>, an integer <var class="Arg">n</var> and a dense list <var class="Arg">L</var>. The output is a new <span class="SimpleMath">\(\mathbb{Z}\)</span>-function whose values between <var class="Arg">n</var> and <var class="Arg">n</var>+<code class="code">Length</code>(<var class="Arg">L</var>)-1 are the entries of <var class="Arg">L</var>.</p>


<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a>   <a href="chap0_mj.html#contents">[Contents]</a>    <a href="chap9_mj.html">[Previous Chapter]</a>    <a href="chapInd_mj.html">[Next Chapter]</a>   </div>


<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a>  <a href="chap1_mj.html">1</a>  <a href="chap2_mj.html">2</a>  <a href="chap3_mj.html">3</a>  <a href="chap4_mj.html">4</a>  <a href="chap5_mj.html">5</a>  <a href="chap6_mj.html">6</a>  <a href="chap7_mj.html">7</a>  <a href="chap8_mj.html">8</a>  <a href="chap9_mj.html">9</a>  <a href="chap10_mj.html">10</a>  <a href="chapInd_mj.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>

100%


¤ Dauer der Verarbeitung: 0.21 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.