Home Explore Help
Sign In
3DFaces
/
libigl_Martin
3
0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Tree: e1eb91246c
Branches Tags
libigl_Martin
/
matlab-to-eigen.html

matlab-to-eigen.html 11 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293 
  1. <html> <head>
    2. 

  2.     <title>MATLAB to Eigen</title>
    3. 

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

  4.   </head>
    5. 

  5.   <body>
    6. 

  6.     <table>
    7. 

  7.       <tr class="header">
    8. 

  8.         <th>MATLAB</th>
    9. 

  9.         <th>Eigen with libigl</th>
    10. 

  10.         <th>Notes</th>
    11. 

  11.       </tr>
    12. 

  12. 

  13.       <tr class=d0>
    14. 

  14.         <td><pre><code>[Y,IX] = sort(X,dim,mode)</code></pre></td>
    15. 

  15.         <td><pre><code>igl::sort(X,dim,mode,Y,IX)</code></pre></td>
    16. 

  16.         <td>MATLAB version allows Y to be a multidimensional matrix, but the
    17. 

  17.         Eigen version is only for 1D or 2D matrices.</td>
    18. 

  18.       </tr>
    19. 

  19. 

  20.       <tr class=d1>
    21. 

  21.         <td><pre><code>B(i:(i+w),j:(j+h)) = A(x:(x+w),y:(y+h))</code></pre></td>
    22. 

  22.         <td><pre><code>B.block(i,j,w,h) = A.block(i,j,w,h)</code></pre></td>
    23. 

  23.         <td>MATLAB version would allow w and h to be non-positive since the
    24. 

  24.         colon operator evaluates to a list of indices, but the Eigen version
    25. 

  25.         needs non-negative width and height values.</td>
    26. 

  26.       </tr>
    27. 

  27. 

  28.       <tr class=d0>
    29. 

  29.         <td><pre><code>max(A(:))</code></pre></td>
    30. 

  30.         <td><pre><code>A.maxCoeff()</code></pre></td>
    31. 

  31.         <td>Find the maximum coefficient over all entries of the matrix.</td>
    32. 

  32.       </tr>
    33. 

  33. 

  34.       <tr class=d1>
    35. 

  35.         <td><pre><code>min(A(:))</code></pre></td>
    36. 

  36.         <td><pre><code>A.minCoeff()</code></pre></td>
    37. 

  37.         <td>Find the minimum coefficient over all entries of the matrix.</td>
    38. 

  38.       </tr>
    39. 

  39. 

  40.       <tr class=d0>
    41. 

  41.         <td><pre><code>eye(w,h)</code></pre></td>
    42. 

  42.         <td><pre><code>MatrixXd::Identity(w,h), MatrixXf::Identity(w,h), etc.</code></pre></td>
    43. 

  43.         <td></td>
    44. 

  44.       </tr>
    45. 

  45. 

  46.       <tr class=d1>
    47. 

  47.         <td><pre><code>A(i:(i+w),j:(j+h)) = eye(w,h)</code></pre></td>
    48. 

  48.         <td><pre><code>A.block(i,j,w,h).setIdentity()</code></pre></td>
    49. 

  49.         <td></td>
    50. 

  50.       </tr>
    51. 

  51. 

  52.       <tr class=d0>
    53. 

  53.         <td><pre><code>[I,J,V] = find(X)</code></pre></td>
    54. 

  54.         <td><pre><code>igl::find(X,I,J,V)</code></pre></td>
    55. 

  55.         <td>Matlab supports finding subscripts (I and J) as well as indices
    56. 

  56.         (just I), but so far igl::find only supports subscripts. Also,
    57. 

  57.         igl::find requires X to be sparse.</td>
    58. 

  58.       </tr>
    59. 

  59. 

  60.       <tr class=d1>
    61. 

  61.         <td><pre><code>X(:,j) = X(:,j) + x</code></pre></td>
    62. 

  62.         <td><pre><code>X.col(j).array() += x</code></pre></td>
    63. 

  63.         <td></td>
    64. 

  64.       </tr>
    65. 

  65. 

  66.       <tr class=d0>
    67. 

  67.         <td><pre><code>Acol_sum = sum(A,1)<br>Arow_sum = sum(A,2)<br>Adim_sum = sum(Asparse,dim)</code></pre></td>
    68. 

  68.         <td><pre><code>Acol_sum = A.colwise().sum()<br>Arow_sum = A.rowwise().sum()<br>igl::sum(Asparse,dim,Adim_sum)</code></pre></td>
    69. 

  69.         <td>Currently the igl version only supports sparse matrix input (and
    70. 

  70.             dim must be 1 or 2)</td>
    71. 

  71.       </tr>
    72. 

  72. 

  73.       <tr class=d1>
    74. 

  74.         <td><pre><code>D = diag(M)</code></pre></td>
    75. 

  75.         <td><pre><code>igl::diag(M,D)</code></pre></td>
    76. 

  76.         <td>Extract the main diagonal of a matrix. Currently igl version
    77. 

  77.         supports sparse only.</td>
    78. 

  78.       </tr>
    79. 

  79. 

  80.       <tr class=d0>
    81. 

  81.         <td><pre><code>M = diag(D)</code></pre></td>
    82. 

  82.         <td><pre><code>igl::diag(D,M)</code></pre></td>
    83. 

  83.         <td>Construct new square matrix M with entries of vector D along the
    84. 

  84.         diagonal. Currently igl version supports sparse only.</td>
    85. 

  85.       </tr>
    86. 

  86. 

  87.       <tr class=d1>
    88. 

  88.         <td><pre><code>[Y,I] = max(X,[],dim)</code></pre></td>
    89. 

  89.         <td id=mat_max><pre><code>igl::mat_max(X,dim,Y,I)</code></pre></td>
    90. 

  90.         <td>Matlab has a bizarre convention of passing [] as the second
    91. 

  91.           argument to mean take the max/min along dimension dim.</td>
    92. 

  92.       </tr>
    93. 

  93. 

  94.       <tr class=d0>
    95. 

  95.         <td><pre><code>Y = max(X,[],1)<br>Y = max(X,[],2)<br>Y = min(X,[],1)<br>Y = min(X,[],2)</code></pre></td>
    96. 

  96.         <td><pre><code>Y = X.colwise().maxCoeff()<br>Y = X.rowwise().maxCoeff()<br>Y = X.colwise().minCoeff()<br>Y = X.rowwise().minCoeff()</code></pre></td>
    97. 

  97.         <td>Matlab allows you to obtain the indices of extrema see <a href=#mat_max>mat_max</a></td>
    98. 

  98.       </tr>
    99. 

  99. 

  100.       <tr class=d1>
    101. 

  101.         <td><pre><code>C = A.*B</code></pre></td>
    102. 

  102.         <td><pre><code>C = (A.array() * B.array()).matrix()</code></pre></td>
    103. 

  103.         <td></td>
    104. 

  104.       </tr>
    105. 

  105. 

  106.       <tr class=d0>
    107. 

  107.         <td><pre><code>C = A.^b</code></pre></td>
    108. 

  108.         <td><pre><code>C = A.array().pow(b).matrix()</code></pre></td>
    109. 

  109.         <td></td>
    110. 

  110.       </tr>
    111. 

  111. 

  112.       <tr class=d1>
    113. 

  113.         <td><pre><code>A(B == 0) = C(B==0)</code></pre></td>
    114. 

  114.         <td><pre><code>A = (B.array() == 0).select(C,A)</code></pre></td>
    115. 

  115.         <td></td>
    116. 

  116.       </tr>
    117. 

  117. 

  118.       <tr class=gotcha1>
    119. 

  119.         <td><pre><code>C = A + B'</code></pre></td>
    120. 

  120.         <td><pre><code>SparseMatrixType BT = B.transpose()<br>SparseMatrixType C = A+BT;</code></pre></td>
    121. 

  121.         <td>Do <b>not</b> attempt to combine .transpose() in expression like
    122. 

  122.         this: <pre><code>C = A + B.transpose()</code></pre></td>
    123. 

  123.       </tr>
    124. 

  124. 

  125.       <tr class=gotcha2>
    126. 

  126.         <td><pre><code>[L,p] = chol(A)</code></pre></td>
    127. 

  127.         <td><pre><code>SparseLLT&lt;SparseMatrixType&gt; A_LLT(A.template triangularView&lt;Lower&gt;())<br>SparseMatrixType L = A_LLT.matrixL();bool p = (L*0).eval().nonZeros()==0;</code></pre></td>
    128. 

  128.         <td>Do <b>not</b> attempt to use A in constructor of A_LLT like
    129. 

  129.         this: <pre><code>SparseLLT&lt;SparseMatrixType&gt; A_LLT(A)</code></pre><br>
    130. 

  130.         Do <b>not</b> attempt to use A_LLT.succeeded() to determine if Cholesky
    131. 

  131.         factorization succeeded, like this:
    132. 

  132.         <pre><code>bool p = A_LLT.succeeded()</code></pre>
    133. 

  133.         </td>
    134. 

  134.       </tr>
    135. 

  135. 

  136.       <tr class=d0>
    137. 

  137.         <td><pre><code>X = U\(L\b)</code></pre></td>
    138. 

  138.         <td><pre><code>X = b;<br>L.template triangularView&lt;Lower&gt;().solveInPlace(X);<br>U.template triangularView&lt;Upper&gt;().solveInPlace(X);</code></pre></td>
    139. 

  139.         <td>Expects that L and U are lower and upper triangular matrices
    140. 

  140.         respectively</td>
    141. 

  141.       </tr>
    142. 

  142. 

  143.       <tr class=d1>
    144. 

  144.         <td><pre><code>B = repmat(A,i,j)</code></pre></td>
    145. 

  145.         <td><pre><code>igl::repmat(A,i,j,B);
    146. 

  146. B = A.replicate(i,j);</code></pre></td>
    147. 

  147.         <td>igl::repmat is also implemented for Sparse Matrices.
    148. 

  148.         </td>
    149. 

  149.       </tr>
    150. 

  150. 

  151.       <tr class=d0>
    152. 

  152.         <td><pre><code>I = low:step:hi</code></pre></td>
    153. 

  153.         <td><pre><code>igl::colon(low,step,hi,I);
    154. 

  154. // or
    155. 

  155. const int size = ((hi-low)/step)+1;
    156. 

  156. I = VectorXiLinSpaced(size,low,low+step*(size-1));</code></pre></td>
    157. 

  157.         <td>IGL version should be templated enough to handle same situations as
    158. 

  158.         matlab's colon. The matlab keyword <b>end</b> does not correspond in
    159. 

  159.         the C++ version. You'll have to use M.size(),M.rows() or whatever.
    160. 

  160.         </td>
    161. 

  161.       </tr>
    162. 

  162. 

  163.       <tr class=d1>
    164. 

  164.         <td><pre><code>O = ones(m,n)</code></pre></td>
    165. 

  165.         <td><pre><code>Matrix* O = Matrix*::Ones(m,n)</code></pre></td>
    166. 

  166.         <td></td>
    167. 

  167.       </tr>
    168. 

  168. 

  169.       <tr class=d0>
    170. 

  170.         <td><pre><code>O = zeros(m,n)</code></pre></td>
    171. 

  171.         <td><pre><code>Matrix* O = Matrix*::Zero(m,n)</code></pre></td>
    172. 

  172.         <td></td>
    173. 

  173.       </tr>
    174. 

  174. 

  175.       <tr class=d1>
    176. 

  176.         <td><pre><code>B = A(I,J)<br>B = A(I,:)</code></pre></td>
    177. 

  177.         <td><pre><code>igl::slice(A,I,J,B)<br>B = igl::slice(A,I,igl::colon(0,A.cols()-1))</code></pre></td>
    178. 

  178.         <td>This is only for the case when I and J are lists of indices and
    179. 

  179.         not vectors of logicals.</td>
    180. 

  180.       </tr>
    181. 

  181. 

  182.       <tr class=d0>
    183. 

  183.         <td><pre><code>B(I,J) = A<br>B(I,:) = A</code></pre></td>
    184. 

  184.         <td><pre><code>igl::slice_into(A,I,J,B)<br>B = igl::slice_into(A,I,igl::colon(0,B.cols()-1))</code></pre></td>
    185. 

  185.         <td>This is only for the case when I and J are lists of indices and
    186. 

  186.         not vectors of logicals.</td>
    187. 

  187.       </tr>
    188. 

  188. 

  189.       <tr class=d1>
    190. 

  190.         <td><pre><code>M = mode(X,dim)</code></pre></td>
    191. 

  191.         <td><pre><code>igl::mode(X,dim,M)</code></pre></td>
    192. 

  192.         <td></td>
    193. 

  193.       </tr>
    194. 

  194. 

  195.       <tr class=d0>
    196. 

  196.         <td><pre><code>B = arrayfun(FUN, A)</code></pre></td>
    197. 

  197.         <td><pre><code>B = A.unaryExpr(ptr_fun(FUN))</code></pre></td>
    198. 

  198.         <td>If FUN is templated, the templates must be fully resolved.</td>
    199. 

  199.       </tr>
    200. 

  200. 

  201.       <tr class=d1>
    202. 

  202.         <td><pre><code>B = fliplr(A)<br>B = flipud(A)</code></pre></td>
    203. 

  203.         <td><pre><code>B = A.rowwise().reverse().eval()<br>B =
    204. 

  204. 	A.colwise().reverse().eval()</code></pre></td>
    205. 

  205.         <td>The <code>.eval()</code> is not necessary if A != B</td>
    206. 

  206.       </tr>
    207. 

  207. 

  208.       <tr class=d0>
    209. 

  209.         <td><pre><code>B = IM(A)
    210. 

  210. 

  211. A = IM(A);
    212. 

  212.   </code></pre></td>
    213. 

  213.         <td><pre><code>B = A.unaryExpr(bind1st(mem_fun( 
    214. 

  214.   static_cast&lt;VectorXi::Scalar&amp;(VectorXi::*)(VectorXi::Index)&gt;
    215. 

  215.   (&amp;VectorXi::operator())), &amp;IM)).eval();
    216. 

  216. // or
    217. 

  217. for_each(A.data(),A.data()+A.size(),[&amp;IM](int &amp; a){a=IM(a);});
    218. 

  218.   </code></pre></td>
    219. 

  219.         <td>Where IM is an "index map" column vector and A is an arbitrary
    220. 

  220.         matrix. The <code>.eval()</code> is not necessary if A != B, but then
    221. 

  221.         the second option should be used.</td>
    222. 

  222.       </tr>
    223. 

  223. 

  224.       <tr class=d1>
    225. 

  225.         <td><pre><code>A = sparse(I,J,V)</code></pre></td>
    226. 

  226.         <td><pre><code>// build std::vector&ltEigen::Triplet&gt; IJV
    227. 

  227. A.setFromTriplets(IJV);
    228. 

  228.         </code></pre></td>
    229. 

  229.         <td>IJV and A should not be empty! (this might be fixed)</td>
    230. 

  230.       </tr>
    231. 

  231. 

  232. 

  233.       <tr class=d0>
    234. 

  234.         <td><pre><code>A = min(A,c);</code></pre></td>
    235. 

  235.         <td><pre><code>C.array() = A.array().min(c);
    236. 

  236.         </code></pre></td>
    237. 

  237.         <td>Coefficient-wise minimum of matrix and scalar (or matching size matrix)</td>
    238. 

  238.       </tr>
    239. 

  239. 

  240.       <tr class=d1>
    241. 

  241.         <td><pre><code>I=1:10;
    242. 

  242. ...
    243. 

  243. IP = I(P==0);</code></pre></td>
    244. 

  244.         <td><pre><code>I = VectorXi::LinSpaced(10,0,9);
    245. 

  245. ...
    246. 

  246. VectorXi IP = I;
    247. 

  247. IP.conservativeResize(stable_partition(
    248. 

  248.   IP.data(), 
    249. 

  249.   IP.data()+IP.size(), 
    250. 

  250.   [&amp;P](int i){return P(i)==0;})-IP.data());
    251. 

  251.         </code></pre></td>
    252. 

  252.         <td>Where I is a vector of increasing indices from 0 to n, and P is a vector. <i>Requires C++11 and <code>#include &lt;algorithm&gt;</code></i></td>
    253. 

  253.       </tr>
    254. 

  254. 

  255.       <tr class=d0>
    256. 

  256.         <td><pre><code>B = A(R&lt;2,C&gt;1);</code></pre>
    257. 

  257.         <td><pre><code>B = igl::slice_mask(A,R.array()&lt;2,C.array()&gt;1);</code></pre>
    258. 

  258.         <td></td>
    259. 

  259.       </tr>
    260. 

  260. 

  261.       <tr class=d1>
    262. 

  262.         <td><pre><code>a = any(A(:))</code></pre></td>
    263. 

  263.         <td><pre><code><del>bool a = any_of(A.data(),A.data()+A.size(),[](bool a){ return a;});</del>
    264. 

  264. bool a = A.array().any();
    265. 

  265.         </code></pre></td>
    266. 

  266.         <td>Casts <code>Matrix::Scalar<code> to <code>bool</code>.</td>
    267. 

  267.       </tr>
    268. 

  268. 

  269.       <tr class=d0>
    270. 

  270.         <td><pre><code>B = mod(A,2)</code></pre></td>
    271. 

  271.         <td><pre><code>igl::mod(A,2,B)</code></pre></td>
    272. 

  272.         <td></td>
    273. 

  273.       </tr>
    274. 

  274. 

  275.       <!-- Insert rows for each command pair -->
    276. 

  276. 

  277.       <!-- Leave this here for copy and pasting
    278. 

  278. 

  279.       <tr class=d0>
    280. 

  280.         <td><pre><code>Matlab code</code></pre></td>
    281. 

  281.         <td><pre><code>Eigen code</code></pre></td>
    282. 

  282.         <td>Notes</td>
    283. 

  283.       </tr>
    284. 

  284. 

  285.       -->
    286. 

  286. 

  287.     </table>
    288. 

  288.     <a href="http://eigen.tuxfamily.org/dox/AsciiQuickReference.txt">Eigen's
    289. 

  289.     "ASCII Quick Reference" with MATLAB translations</a>
    290. 

  290.     <br>
    291. 

  291.     <a href="./tutorial.html">IGL Lib Tutorial</a>
    292. 

  292.   </body>
    293. 

  293. </html>
    294.