Skip to content

Commit

Permalink
deploy: 76ab201
Browse files Browse the repository at this point in the history
  • Loading branch information
@bkorecic
bkorecic committed Oct 21, 2024
1 parent 4fa346d commit bba34da
Showing 1 changed file with 12 additions and 8 deletions.
20 changes: 12 additions & 8 deletions apunte/geometria/puntos/index.html
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,13 +45,12 @@
</span></span><span class=line><span class=cl> <span class=n>y</span> <span class=o>=</span> <span class=n>_y</span><span class=p>;</span>
</span></span><span class=line><span class=cl> <span class=p>}</span>
</span></span><span class=line><span class=cl><span class=p>};</span>
</span></span></code></pre></div><p>Esta <code>struct</code> guarda simplemente las coordenadas <code>x</code> e <code>y</code>, y por defecto sus valores son cero. Tenemos dos constructores, el primero sin argumentos asigna cero, y el segundo.</p><details><summary>Ejemplo de uso</summary><p>Distintas formas de inicializar un punto y el valor que se obtiene:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-cpp data-lang=cpp><span class=line><span class=cl><span class=n>Point</span> <span class=n>a</span> <span class=o>=</span> <span class=n>Point</span><span class=p>();</span> <span class=c1>// se llaman con parámetros por defecto, a = {0, 0}
</span></span></code></pre></div><p>Esta <code>struct</code> guarda simplemente las coordenadas <code>x</code> e <code>y</code>, y por defecto sus valores son cero. Tenemos dos constructores, el primero es sin argumentos, este asigna cero a las coordenadas, y el segundo recibe dos enteros, estos se asignan en orden a las coordenadas <code>x</code> e <code>y</code>.</p><details><summary>Ejemplo de uso</summary><p>Hay distintas formas de inicializar un punto, las ya nombradas y dos más que podrían resultarles útiles:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-cpp data-lang=cpp><span class=line><span class=cl><span class=n>Point</span> <span class=n>a</span> <span class=o>=</span> <span class=n>Point</span><span class=p>();</span> <span class=c1>// se llaman con parámetros por defecto, a = {0, 0}
</span></span></span><span class=line><span class=cl><span class=c1></span><span class=n>Point</span> <span class=n>b</span> <span class=o>=</span> <span class=n>Point</span><span class=p>(</span><span class=mi>1</span><span class=p>,</span> <span class=mi>2</span><span class=p>)</span> <span class=c1>// b = {1, 2}.
</span></span></span><span class=line><span class=cl><span class=c1></span><span class=n>Point</span> <span class=n>c</span> <span class=o>=</span> <span class=p>{</span><span class=mi>2</span><span class=p>,</span><span class=mi>5</span><span class=p>};</span> <span class=c1>// c = {2,5}, inicialización por copia.
</span></span></span><span class=line><span class=cl><span class=c1></span><span class=n>Point</span> <span class=n>d</span><span class=p>{</span><span class=mi>2</span><span class=p>,</span><span class=mi>5</span><span class=p>};</span> <span class=c1>// d = {2,5}, inicialización directa.
</span></span></span><span class=line><span class=cl><span class=c1></span>
</span></span><span class=line><span class=cl><span class=n>cout</span> <span class=o>&lt;&lt;</span> <span class=n>d</span><span class=p>.</span><span class=n>x</span> <span class=o>&lt;&lt;</span> <span class=sc>&#39; &#39;</span> <span class=o>&lt;&lt;</span> <span class=n>d</span><span class=p>.</span><span class=n>y</span> <span class=o>&lt;&lt;</span> <span class=n>endl</span><span class=p>;</span> <span class=c1>// Acceder a x e y
</span></span></span></code></pre></div></details><p>Podemos simplificar un poco el constructor usando una <a href=https://www.learncpp.com/cpp-tutorial/constructor-member-initializer-lists/>member initializer list</a>. En este caso no hace tanta diferencia, pero queda más compacto (y es una buena práctica):</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-cpp data-lang=cpp><span class=line><span class=cl><span class=k>struct</span> <span class=nc>Point</span><span class=p>{</span>
</span></span></span></code></pre></div><p>Además una vez creado un punto podemos acceder a sus coordenadas de la siguente forma</p><pre tabindex=0><code>cout &lt;&lt; d.x &lt;&lt; &#39; &#39; &lt;&lt; d.y &lt;&lt; endl; // Acceder a x e y
</code></pre></details><p>Podemos simplificar un poco el constructor usando una <a href=https://www.learncpp.com/cpp-tutorial/constructor-member-initializer-lists/>member initializer list</a>. En este caso no hace tanta diferencia, pero queda más compacto (y es una buena práctica):</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-cpp data-lang=cpp><span class=line><span class=cl><span class=k>struct</span> <span class=nc>Point</span><span class=p>{</span>
</span></span><span class=line><span class=cl> <span class=kt>int</span> <span class=n>x</span><span class=p>,</span> <span class=n>y</span><span class=p>;</span>
</span></span><span class=line><span class=cl> <span class=n>Point</span><span class=p>(</span><span class=kt>int</span> <span class=n>_x</span><span class=o>=</span><span class=mi>0</span><span class=p>,</span> <span class=kt>int</span> <span class=n>_y</span><span class=o>=</span><span class=mi>0</span><span class=p>)</span> <span class=o>:</span> <span class=n>x</span><span class=p>(</span><span class=n>_x</span><span class=p>),</span> <span class=n>y</span><span class=p>(</span><span class=n>_y</span><span class=p>)</span> <span class=p>{}</span>
</span></span><span class=line><span class=cl><span class=p>};</span>
Expand Down Expand Up @@ -79,6 +78,9 @@
</span></span><span class=line><span class=cl> <span class=c1>// Multiplicación y división coordenada a coordenada
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=n>Point</span> <span class=k>operator</span><span class=o>*</span><span class=p>(</span><span class=n>Point</span> <span class=n>p</span><span class=p>)</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=nf>Point</span><span class=p>(</span><span class=n>x</span><span class=o>*</span><span class=n>p</span><span class=p>.</span><span class=n>x</span><span class=p>,</span> <span class=n>y</span><span class=o>*</span><span class=n>p</span><span class=p>.</span><span class=n>y</span><span class=p>);</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=n>Point</span> <span class=k>operator</span><span class=o>/</span><span class=p>(</span><span class=n>Point</span> <span class=n>p</span><span class=p>)</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=nf>Point</span><span class=p>(</span><span class=n>x</span><span class=o>/</span><span class=n>p</span><span class=p>.</span><span class=n>x</span><span class=p>,</span> <span class=n>y</span><span class=o>/</span><span class=n>p</span><span class=p>.</span><span class=n>y</span><span class=p>);</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=c1>// Multiplicación y división por escalares
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=n>Point</span> <span class=k>operator</span><span class=o>*</span><span class=p>(</span><span class=n>T</span> <span class=n>lambda</span><span class=p>)</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=nf>Point</span><span class=p>(</span><span class=n>x</span><span class=o>*</span><span class=n>lambda</span><span class=p>,</span> <span class=n>y</span><span class=o>*</span><span class=n>lambda</span><span class=p>);</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=n>Point</span> <span class=k>operator</span><span class=o>/</span><span class=p>(</span><span class=n>T</span> <span class=n>lambda</span><span class=p>)</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=nf>Point</span><span class=p>(</span><span class=n>x</span><span class=o>/</span><span class=n>lambda</span><span class=p>,</span> <span class=n>y</span><span class=o>/</span><span class=n>lambda</span><span class=p>);</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=c1>// Menor e igualdad. Usamos tie que retorna una tupla (y por ende compara en orden de izq. a der.)
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=kt>bool</span> <span class=k>operator</span><span class=o>&lt;</span><span class=p>(</span><span class=n>Point</span> <span class=n>p</span><span class=p>)</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=nf>tie</span><span class=p>(</span><span class=n>x</span><span class=p>,</span><span class=n>y</span><span class=p>)</span> <span class=o>&lt;</span> <span class=n>tie</span><span class=p>(</span><span class=n>p</span><span class=p>.</span><span class=n>x</span><span class=p>,</span> <span class=n>p</span><span class=p>.</span><span class=n>y</span><span class=p>);</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=kt>bool</span> <span class=k>operator</span><span class=o>==</span><span class=p>(</span><span class=n>Point</span> <span class=n>p</span><span class=p>)</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=nf>tie</span><span class=p>(</span><span class=n>x</span><span class=p>,</span><span class=n>y</span><span class=p>)</span> <span class=o>==</span> <span class=n>tie</span><span class=p>(</span><span class=n>p</span><span class=p>.</span><span class=n>x</span><span class=p>,</span> <span class=n>p</span><span class=p>.</span><span class=n>y</span><span class=p>);</span> <span class=p>}</span>
Expand All @@ -93,10 +95,12 @@
</span></span><span class=line><span class=cl> <span class=c1>// unit retorna el vector normalizado (largo 1)
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=n>Point</span> <span class=nf>unit</span><span class=p>()</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=o>*</span><span class=k>this</span><span class=o>/</span><span class=n>dist</span><span class=p>();</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=c1>// perp obtiene un vector perpendicular, es decir rota en +90 grados
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=n>Point</span> <span class=nf>perp</span><span class=p>()</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=n>P</span><span class=p>(</span><span class=o>-</span><span class=n>y</span><span class=p>,</span> <span class=n>x</span><span class=p>);</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=c1>// normal retorna un vector normal unitario
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=n>Point</span> <span class=nf>normal</span><span class=p>()</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=n>perp</span><span class=p>().</span><span class=n>unit</span><span class=p>();</span> <span class=p>}</span>
</span></span><span class=line><span class=cl>
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=n>Point</span> <span class=nf>perp</span><span class=p>()</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=n>Point</span><span class=p>(</span><span class=o>-</span><span class=n>y</span><span class=p>,</span> <span class=n>x</span><span class=p>);</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=c1>// normal retorna un vector normal unitario (convencion normal a (0,0) = (inf,inf))
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=n>Point</span> <span class=nf>normal</span><span class=p>()</span> <span class=k>const</span> <span class=p>{</span> <span class=k>return</span> <span class=n>perp</span><span class=p>().</span><span class=n>unit</span><span class=p>();</span> <span class=p>}</span>
</span></span><span class=line><span class=cl> <span class=c1>// vector normal unitario (convencion normal a (0,0) = (0,0))
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=c1>// Point normal() const { return (*this == Point()) ? *this : perp().unit(); }
</span></span></span><span class=line><span class=cl><span class=c1></span>
</span></span><span class=line><span class=cl> <span class=c1>// Además se puede hacer overload de operadores &#34;&gt;&gt;&#34; y &#34;&lt;&lt;&#34; para que poder leer/imprimir Point con cin/cout
</span></span></span><span class=line><span class=cl><span class=c1></span> <span class=k>friend</span> <span class=n>istream</span><span class=o>&amp;</span> <span class=k>operator</span><span class=o>&gt;&gt;</span><span class=p>(</span><span class=n>istream</span><span class=o>&amp;</span> <span class=n>is</span><span class=p>,</span> <span class=n>Point</span> <span class=o>&amp;</span><span class=n>p</span><span class=p>){</span>
</span></span><span class=line><span class=cl> <span class=k>return</span> <span class=n>is</span> <span class=o>&gt;&gt;</span> <span class=n>p</span><span class=p>.</span><span class=n>x</span> <span class=o>&gt;&gt;</span> <span class=n>p</span><span class=p>.</span><span class=n>y</span><span class=p>;</span>
Expand Down

0 comments on commit bba34da

Please sign in to comment.