PageRenderTime 49ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/vigra-1.8.0/doc/vigra/NumericTraits.html

#
HTML | 182 lines | 172 code | 8 blank | 2 comment | 0 complexity | 470e5c7acd332e1eb434889a27f253ff MD5 | raw file
    

  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    2. 

  2. <html><head><TITLE>vigra - vigra: template&lt;&gt; struct NumericTraits&lt;ArithmeticType&gt;</TITLE>
    3. 

  3. <link rel=stylesheet type="text/css" href="vigra.css">
    4. 

  4. <link rel="shortcut icon" href="vigra-icon.ico" />
    5. 

  5. </head>
    6. 

  6. <body  bgcolor="#f8f0e0" link="#0040b0" vlink="#a00040">
    7. 

  7. <basefont face="Helvetica,Arial,sans-serif" size=3>
    8. 

  8. <p align=right>
    9. 

  9. [ <a href="http://hci.iwr.uni-heidelberg.de/vigra/">VIGRA Homepage</a> |
    10. 

  10.  <a href="functionindex.html">Function Index</a> |
    11. 

  11.  <a href="classes.html">Class Index</a> |
    12. 

  12.  <a href="namespaces.html">Namespaces</a> |
    13. 

  13.  <a href="files.html">File List</a> |
    14. 

  14.  <a href="index.html">Main Page</a> ]
    15. 

  15. </p>
    16. 

  16. <!-- Generated by Doxygen 1.6.3 -->
    17. 

  17. <div class="contents">
    18. 

  18. 

  19. 

  20. <h1><a class="anchor" id="NumericTraits">template&lt;&gt; struct NumericTraits&lt;ArithmeticType&gt; </a></h1><p>Unary traits for promotion, conversion, creation of arithmetic objects.</p>
    21. 

  21. <p><b>#include</b> &lt;<a class="el" href="numerictraits_8hxx_source.html">vigra/numerictraits.hxx</a>&gt;</p>
    22. 

  22. <p>This traits class is used derive important properties of an arithmetic type. Consider the following algorithm:</p>
    23. 

  23. <div class="fragment"><pre class="fragment">    <span class="comment">// calculate the sum of a sequence of bytes</span>
    24. 

  24.     <span class="keywordtype">int</span> sumBytes(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> * begin, <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> * end)
    25. 

  25.     {
    26. 

  26.         <span class="keywordtype">int</span> result = 0;
    27. 

  27.         <span class="keywordflow">for</span>(; begin != end; ++begin)  result += *begin;
    28. 

  28.         <span class="keywordflow">return</span> result;
    29. 

  29.     }
    30. 

  30. </pre></div><p>The return type of this function can not be 'unsigned char' because the summation would very likely overflow. Since we know the source type, we can easily choose 'int' as an appropriate return type. Likewise, we would have chosen 'float' if we had to sum a sequence of floats. If we want to make this algorithm generic, we would like to derive the appropriate return type automatically. This can be done with NumericTraits. The code would look like this (we use <a class="el" href="group__DataAccessors.html">Data Accessors</a> to read the data from the sequence):</p>
    31. 

  31. <div class="fragment"><pre class="fragment">    <span class="comment">// calculate the sum of any sequence</span>
    32. 

  32.     <span class="keyword">template</span> &lt;<span class="keyword">class</span> Iterator, <span class="keyword">class</span> Accessor&gt;
    33. 

  33.     <span class="keyword">typename</span> vigra::NumericTraits&lt;typename Accessor::value_type&gt;::Promote
    34. 

  34.     sumSequence(Iterator begin, Iterator end, Accessor a)
    35. 

  35.     {
    36. 

  36.         <span class="comment">// an abbreviation</span>
    37. 

  37.         <span class="keyword">typedef</span> vigra::NumericTraits&lt;typename Accessor::value_type&gt;  SrcTraits;
    38. 

  38.         
    39. 

  39.         <span class="comment">// find out result type</span>
    40. 

  40.         <span class="keyword">typedef</span> <span class="keyword">typename</span> SrcTraits::Promote ResultType;
    41. 

  41.       
    42. 

  42.         <span class="comment">// init result to zero</span>
    43. 

  43.         ResultType result = vigra::NumericTraits&lt;ResultType&gt;::zero();
    44. 

  44.     
    45. 

  45.         <span class="keywordflow">for</span>(; begin != end; ++begin)
    46. 

  46.         {  
    47. 

  47.             <span class="comment">// cast current item to ResultType and add</span>
    48. 

  48.             result += SrcTraits::toPromote(a(begin));
    49. 

  49.         }
    50. 

  50.         
    51. 

  51.         <span class="keywordflow">return</span> result;
    52. 

  52.     }
    53. 

  53. </pre></div><p>In this example NumericTraits is not only used to deduce the ReturnType of the operation, but also to initialize it with the constant 'zero'. This is necessary since we do not know in general, which expression must be used to obtain a zero of some arbitrary type - '<code>ResultType result = 0;</code>' would only work if the ResultType had an constructor taking an '<code>int</code>' argument, and we would not even have any guarantee as to what the semantics of this constructor are. In addition, the traits are used to cast the source type into the promote type.</p>
    54. 

  54. <p>Similarly, an algorithm that needs multiplication would use the return type <code>RealPromote</code> and the functions <code>one()</code> and <code>toRealPromote()</code>. The following members are defined in <b> <code>NumericTraits&lt;ArithmeticType&gt;</code></b>:</p>
    55. 

  55. <table class="doxtable">
    56. 

  56. <tr>
    57. 

  57. <td><b> <code>typedef ... Type;</code></b> </td><td><p class="starttd"></p>
    58. 

  58. <p>the type itself</p>
    59. 

  59. <p class="endtd"></p>
    60. 

  60. </td></tr>
    61. 

  61. <tr>
    62. 

  62. <td><b> <code>typedef ... Promote;</code></b> </td><td><p class="starttd"></p>
    63. 

  63. <p>promote type for addition and subtraction</p>
    64. 

  64. <p class="endtd"></p>
    65. 

  65. </td></tr>
    66. 

  66. <tr>
    67. 

  67. <td><b> <code>typedef ... RealPromote;</code></b> </td><td><p class="starttd">promote type for multiplication and division with a real number</p>
    68. 

  68. <p>(only defined if <code>ArithmeticType</code> supports these operations)</p>
    69. 

  69. <p class="endtd"></p>
    70. 

  70. </td></tr>
    71. 

  71. <tr>
    72. 

  72. <td><b> <code>typedef ... ComplexPromote;</code></b> </td><td><p class="starttd"></p>
    73. 

  73. <p>promote type for complex arithmetic</p>
    74. 

  74. <p class="endtd"></p>
    75. 

  75. </td></tr>
    76. 

  76. <tr>
    77. 

  77. <td><b> <code>typedef ... ValueType;</code></b> </td><td><p class="starttd"></p>
    78. 

  78. <p>for scalar types: the type itself<br/>
    79. 

  79.  otherwise: typename Type::value_type (if defined)</p>
    80. 

  80. <p class="endtd"></p>
    81. 

  81. </td></tr>
    82. 

  82. <tr>
    83. 

  83. <td><b> <code>static Promote toPromote(ArithmeticType v);</code></b> </td><td><p class="starttd">convert to <code>Promote</code> type</p>
    84. 

  84. <p class="endtd"></p>
    85. 

  85. </td></tr>
    86. 

  86. <tr>
    87. 

  87. <td><b> <code>static RealPromote toRealPromote(ArithmeticType v);</code></b> </td><td><p class="starttd">convert to <code>RealPromote</code> type</p>
    88. 

  88. <p>(only defined if <code>ArithmeticType</code> supports multiplication)</p>
    89. 

  89. <p class="endtd"></p>
    90. 

  90. </td></tr>
    91. 

  91. <tr>
    92. 

  92. <td><b> <code>static ArithmeticType fromPromote(Promote v);</code></b> </td><td><p class="starttd">convert from <code>Promote</code> type</p>
    93. 

  93. <p>if <code>v</code> is outside the range of <code>ArithmeticType</code> it is clipped;</p>
    94. 

  94. <p class="endtd"></p>
    95. 

  95. </td></tr>
    96. 

  96. <tr>
    97. 

  97. <td><b> <code>static ArithmeticType fromRealPromote(RealPromote v);</code></b> </td><td><p class="starttd">convert from <code>RealPromote</code> type</p>
    98. 

  98. <p>(only defined if <code>ArithmeticType</code> supports multiplication)</p>
    99. 

  99. <p>if <code>ArithmeticType</code> is an integral type, the result is rounded</p>
    100. 

  100. <p>if <code>v</code> is outside the range of <code>ArithmeticType</code> it is clipped</p>
    101. 

  101. <p class="endtd"></p>
    102. 

  102. </td></tr>
    103. 

  103. <tr>
    104. 

  104. <td><b> <code>static ArithmeticType zero();</code></b> </td><td><p class="starttd">create neutral element of addition</p>
    105. 

  105. <p>i.e. <code>(ArithmeticType a = ...,</code> <code> a + NumericTraits&lt;ArithmeticType&gt;::zero() == a)</code> must always yield <code>true</code></p>
    106. 

  106. <p class="endtd"></p>
    107. 

  107. </td></tr>
    108. 

  108. <tr>
    109. 

  109. <td><b> <code>static ArithmeticType nonZero();</code></b> </td><td><p class="starttd">create a non-zero element (if multiplication is defined, this yields one())</p>
    110. 

  110. <p>i.e. <code>(ArithmeticType a = ...,</code> <code> a + NumericTraits&lt;ArithmeticType&gt;::nonZero() == a)</code> must always yield <code>false</code></p>
    111. 

  111. <p class="endtd"></p>
    112. 

  112. </td></tr>
    113. 

  113. <tr>
    114. 

  114. <td><b> <code>static ArithmeticType <a class="el" href="group__TinyVectorOperators.html#gaec67766e3428b623ce2d8c40a2e0fab9" title="element-wise minimum">min()</a>;</code></b> </td><td><p class="starttd">the smallest number representable in this type.<br/>
    115. 

  115.  Only available if isOrdered is VigraTrueType. For integral types, this equals <code>INT_MIN</code> etc., for real valued types it is <code>-FLT_MAX</code> etc. (<b>not</b> <code>FLT_MIN</code> -- this is the smallest positive <code>float</code>)</p>
    116. 

  116. <p class="endtd"></p>
    117. 

  117. </td></tr>
    118. 

  118. <tr>
    119. 

  119. <td><b> <code>static ArithmeticType <a class="el" href="group__TinyVectorOperators.html#ga229f7791dfea0511293198040e55c5b2" title="element-wise maximum">max()</a>;</code></b> </td><td><p class="starttd">the largest number representable in this type.<br/>
    120. 

  120.  Only available if isOrdered is VigraTrueType. For integral types, this equals <code>INT_MAX</code> etc., for real valued types it is <code>FLT_MAX</code> etc.</p>
    121. 

  121. <p class="endtd"></p>
    122. 

  122. </td></tr>
    123. 

  123. <tr>
    124. 

  124. <td><b> <code>static ArithmeticType one();</code></b> </td><td><p class="starttd">create neutral element of multiplication</p>
    125. 

  125. <p>(only defined if <code>ArithmeticType</code> supports multiplication)</p>
    126. 

  126. <p>i.e. <code>(ArithmeticType a = ...,</code> <code> a * NumericTraits&lt;ArithmeticType&gt;::one() == a)</code> must always yield <code>true</code></p>
    127. 

  127. <p class="endtd"></p>
    128. 

  128. </td></tr>
    129. 

  129. <tr>
    130. 

  130. <td><b> <code>typedef ... isIntegral;</code></b> </td><td><p class="starttd">VigraTrueType if <code>ArithmeticType</code> is an integral type, VigraFalseType otherwise</p>
    131. 

  131. <p class="endtd"></p>
    132. 

  132. </td></tr>
    133. 

  133. <tr>
    134. 

  134. <td><b> <code>typedef ... isScalar;</code></b> </td><td><p class="starttd">VigraTrueType if <code>ArithmeticType</code> is a scalar type, VigraFalseType otherwise</p>
    135. 

  135. <p class="endtd"></p>
    136. 

  136. </td></tr>
    137. 

  137. <tr>
    138. 

  138. <td></td></tr>
    139. 

  139. <tr>
    140. 

  140. <td><b> <code>typedef ... isSigned;</code></b> </td><td><p class="starttd">VigraTrueType if <code>ArithmeticType</code> is a signed type, VigraFalseType otherwise</p>
    141. 

  141. <p class="endtd"></p>
    142. 

  142. </td></tr>
    143. 

  143. <tr>
    144. 

  144. <td></td></tr>
    145. 

  145. <tr>
    146. 

  146. <td><b> <code>typedef ... isOrdered;</code></b> </td><td><p class="starttd">VigraTrueType if <code>ArithmeticType</code> supports <a class="el" href="group__FixedPointOperations.html#gaabd4258d516eb8c9e38f9f97f3160868" title="less than">operator&lt;()</a>, VigraFalseType otherwise</p>
    147. 

  147. <p class="endtd"></p>
    148. 

  148. </td></tr>
    149. 

  149. <tr>
    150. 

  150. <td><b> <code>typedef ... isComplex;</code></b> </td><td><p class="starttd">VigraTrueType if <code>ArithmeticType</code> is a complex number, VigraFalseType otherwise</p>
    151. 

  151. <p class="endtd"></p>
    152. 

  152. </td></tr>
    153. 

  153. <tr>
    154. 

  154. <td></td></tr>
    155. 

  155. </table>
    156. 

  156. <p>NumericTraits for the built-in types are defined in <b>#include</b> &lt;<a class="el" href="numerictraits_8hxx_source.html">vigra/numerictraits.hxx</a>&gt;</p>
    157. 

  157. <p>Namespace: vigra </p>
    158. 

  158. </div>
    159. 

  159. <!-- footer.html -->
    160. 

  160. <p>
    161. 

  161. <table border=0 cellspacing=0 width="100%"  bgcolor="#e0d0a0" cellpadding=5>
    162. 

  162. <tr>
    163. 

  163. <td>
    164. 

  164. <p>
    165. 

  165. <i>&copy; <A HREF="http://hci.iwr.uni-heidelberg.de/people/ukoethe/">Ullrich K&ouml;the</A>     (<A
    166. 

  166. HREF="mailto:ullrich.koethe@iwr.uni-heidelberg.de">ullrich.koethe@iwr.uni-heidelberg.de</A>)</i> <br>
    167. 

  167. <i><A HREF="http://hci.iwr.uni-heidelberg.de/">
    168. 

  168. Heidelberg Collaboratory for Image Processing</a>,
    169. 

  169. University of Heidelberg, Germany</i>
    170. 

  170. <td>
    171. 

  171. <p align=right>
    172. 

  172. <I>html generated using <A HREF="http://www.doxygen.org">doxygen</A> and <A HREF="http://www.python.org">Python</A></I>
    173. 

  173. <br>
    174. 

  174. <i>
    175. 

  175. vigra 1.8.0 (20 Sep 2011)
    176. 

  176. </i>
    177. 

  177. </tr>
    178. 

  178. </table>
    179. 

  179. 

  180. 

  181. </BODY>
    182. 

  182. </HTML>
    183. 

  183.