One Hat Cyber Team

Edit File: __st.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <title>* -- a binary operator, usually used for multiplication</title>
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
    <link type="text/css" rel="stylesheet" href="../../../../Macaulay2/Style/doc.css">

o1 = set {you, hi}

o1 : Set</code></pre>
            </td>
          </tr>
        </table>
        <p></p>
Multiplication involving a list attempts to multiply each element of the list.        <table class="examples">
          <tr>
            <td>
              <pre><code class="language-macaulay2">i2 : R = QQ[a..d];</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i3 : a * {b,c,d}

o3 = {a*b, a*c, a*d}

o3 : List</code></pre>
            </td>
          </tr>
        </table>
        <p></p>
Multiplication of matrices (<a title="matrix multiplication" href="___Matrix_sp_st_sp__Matrix.html">Matrix * Matrix</a>) or ring maps is the same as composition.        <table class="examples">
          <tr>
            <td>
              <pre><code class="language-macaulay2">i4 : f = map(R,R,{b,c,a,d})

o4 = map (R, R, {b, c, a, d})

o4 : RingMap R &lt;-- R</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i5 : g = map(R,R,{(a+b)^2,b^2,c^2,d^2})

2           2   2   2   2
o5 = map (R, R, {a  + 2a*b + b , b , c , d })

o5 : RingMap R &lt;-- R</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i6 : f*g

2           2   2   2   2
o6 = map (R, R, {b  + 2b*c + c , c , a , d })

o6 : RingMap R &lt;-- R</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i7 : (f*g)(a) == f(g(a))

o7 = true</code></pre>
            </td>
          </tr>
        </table>
        <p></p>
Submodules of modules may be produced using multiplication and addition.        <table class="examples">
          <tr>
            <td>
              <pre><code class="language-macaulay2">i8 : M = R^2; I = ideal(a+b,c);

o9 : Ideal of R</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i10 : N = I*M + a*R^2

o10 = image | a+b 0   c 0 a 0 |
            | 0   a+b 0 c 0 a |

2
o10 : R-module, submodule of R</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i11 : isHomogeneous N

o11 = true</code></pre>
            </td>
          </tr>
        </table>
        <h3>Intervals</h3>
        <p>If one of the factors is an <a title="the class of all real intervals" href="___R__Ri.html">RRi</a>, the output is an interval containing all products of pairs in the factors.</p>
        <table class="examples">
          <tr>
            <td>
              <pre><code class="language-macaulay2">i12 : 2*interval(1,3)

o12 = [2,6]

o12 : RRi (of precision 53)</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i13 : interval(1,3)*interval(-1,2)

o13 = [-3,6]

o13 : RRi (of precision 53)</code></pre>
            </td>
          </tr>
          <tr>
            <td>
              <pre><code class="language-macaulay2">i14 : interval(-1,1)*interval(-1,1)

o14 = [-1,1]

o14 : RRi (of precision 53)</code></pre>
            </td>
          </tr>
        </table>
      </div>
      <div>
        <h2>See also</h2>
        <ul>
          <li><span><a title="multiplication" href="_times.html">times</a> -- multiplication</span></li>
          <li><span><a href="_product.html">product</a></span></li>
        </ul>
      </div>
      <div>
        <div class="waystouse">
          <h2>Ways to use <span class="tt">symbol *</span>:</h2>
          <ul>
            <li><kbd>CC * CC</kbd></li>
            <li><kbd>CC * QQ</kbd></li>
            <li><kbd>CC * RR</kbd></li>
            <li><kbd>CC * ZZ</kbd></li>
            <li><kbd>Constant * Constant</kbd></li>
            <li><kbd>Constant * InexactNumber</kbd></li>
            <li><kbd>Constant * Number</kbd></li>
            <li><kbd>Ideal * Module</kbd></li>
            <li><kbd>Ideal * Ring</kbd></li>
            <li><kbd>Ideal * Vector</kbd></li>
            <li><kbd>InexactNumber * Constant</kbd></li>
            <li><kbd>List * Thing</kbd></li>
            <li><kbd>Matrix * Number</kbd></li>
            <li><kbd>Matrix * RingElement</kbd></li>
            <li><kbd>Matrix * Vector</kbd></li>
            <li><kbd>MonomialIdeal * MonomialIdeal</kbd></li>
            <li><kbd>MonomialIdeal * Ring</kbd></li>
            <li><kbd>MutableMatrix * MutableMatrix</kbd></li>
            <li><kbd>Number * Constant</kbd></li>
            <li><kbd>Number * Matrix</kbd></li>
            <li><kbd>Number * Vector</kbd></li>
            <li><kbd>ProjectiveHilbertPolynomial * ZZ</kbd></li>
            <li><kbd>QQ * CC</kbd></li>
            <li><kbd>QQ * QQ</kbd></li>
            <li><kbd>QQ * RR</kbd></li>
            <li><kbd>QQ * RRi</kbd></li>
            <li><kbd>QQ * ZZ</kbd></li>
            <li><kbd>Ring * Ideal</kbd></li>
            <li><kbd>Ring * MonomialIdeal</kbd></li>
            <li><kbd>Ring * RingElement</kbd></li>
            <li><kbd>Ring * Vector</kbd></li>
            <li><kbd>RingElement * Ideal</kbd></li>
            <li><kbd>RingElement * Matrix</kbd></li>
            <li><kbd>RingElement * Module</kbd></li>
            <li><kbd>RingElement * MonomialIdeal</kbd></li>
            <li><kbd>RingElement * MutableMatrix</kbd></li>
            <li><kbd>RingElement * RingElement</kbd></li>
            <li><kbd>RingElement * Vector</kbd></li>
            <li><kbd>RingMap * RingMap</kbd></li>
            <li><kbd>RR * CC</kbd></li>
            <li><kbd>RR * QQ</kbd></li>
            <li><kbd>RR * RR</kbd></li>
            <li><kbd>RR * RRi</kbd></li>
            <li><kbd>RR * ZZ</kbd></li>
            <li><kbd>RRi * QQ</kbd></li>
            <li><kbd>RRi * RR</kbd></li>
            <li><kbd>RRi * RRi</kbd></li>
            <li><kbd>RRi * ZZ</kbd></li>
            <li><kbd>Thing * List</kbd></li>
            <li><kbd>Vector * Number</kbd></li>
            <li><kbd>Vector * RingElement</kbd></li>
            <li><kbd>ZZ * CC</kbd></li>
            <li><kbd>ZZ * ProjectiveHilbertPolynomial</kbd></li>
            <li><kbd>ZZ * QQ</kbd></li>
            <li><kbd>ZZ * RR</kbd></li>
            <li><kbd>ZZ * RRi</kbd></li>
            <li><kbd>ZZ * ZZ</kbd></li>
            <li><span><kbd>QQ * BettiTally</kbd> -- see <span><a title="the class of all Betti tallies" href="___Betti__Tally.html">BettiTally</a> -- the class of all Betti tallies</span></span></li>
            <li><span><kbd>ZZ * BettiTally</kbd> -- see <span><a title="the class of all Betti tallies" href="___Betti__Tally.html">BettiTally</a> -- the class of all Betti tallies</span></span></li>
            <li><span><a title="product of ideals" href="___Ideal_sp_st_sp__Ideal.html">Ideal * Ideal</a> -- product of ideals</span></li>
            <li><span><kbd>Set * Set</kbd> -- see <span><a title="set intersection" href="_intersect_lp__Set_cm__Set_rp.html">intersect(Set,Set)</a> -- set intersection</span></span></li>
            <li><span><a title="matrix multiplication" href="___Matrix_sp_st_sp__Matrix.html">Matrix * Matrix</a> -- matrix multiplication</span></li>
          </ul>
        </div>
        <div class="waystouse">
          <h2>For the programmer</h2>
          <p>The object <a title="a binary operator, usually used for multiplication" href="__st.html">*</a> is <span>a <a title="the class of all keywords" href="___Keyword.html">keyword</a></span>.</p>
          <div>
            <p>This operator may be used as a binary operator in an expression like <span class="tt">x*y</span>. The user may install <a href="_binary_spmethods.html">binary methods</a> for handling such expressions with code such as</p>
            <pre>         X * Y := (x,y) -> ...</pre>
            <p>where <span class="tt">X</span> is the class of <span class="tt">x</span> and <span class="tt">Y</span> is the class of <span class="tt">y</span>.</p>
            <p>This operator may be used as a prefix unary operator in an expression like <span class="tt">*y</span>. The user may <a href="_installing_spmethods.html">install a method</a> for handling such expressions with code such as</p>
            <pre>           * Y := (y) -> ...</pre>
            <p>where <span class="tt">Y</span> is the class of <span class="tt">y</span>.</p>
          </div>
        </div>
        <hr>
        <div class="waystouse">
          <p>The source of this document is in <span class="tt">Macaulay2Doc/operators/times.m2:148:0</span>.</p>
        </div>
      </div>
    </div>
  </body>

</html>