fork download
copy 
  1.  
  2. /*
  3.  
  4.   ██████╗ ██╗   ██╗ █████╗ ███╗   ██╗████████╗██╗   ██╗███╗   ███╗    ███████╗██████╗  █████╗  ██████╗████████╗██╗   ██╗██████╗ ███████╗
  5.  ██╔═══██╗██║   ██║██╔══██╗████╗  ██║╚══██╔══╝██║   ██║████╗ ████║    ██╔════╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██║   ██║██╔══██╗██╔════╝
  6.  ██║   ██║██║   ██║███████║██╔██╗ ██║   ██║   ██║   ██║██╔████╔██║    █████╗  ██████╔╝███████║██║        ██║   ██║   ██║██████╔╝█████╗
  7.  ██║▄▄ ██║██║   ██║██╔══██║██║╚██╗██║   ██║   ██║   ██║██║╚██╔╝██║    ██╔══╝  ██╔══██╗██╔══██║██║        ██║   ██║   ██║██╔══██╗██╔══╝
  8.  ╚██████╔╝╚██████╔╝██║  ██║██║ ╚████║   ██║   ╚██████╔╝██║ ╚═╝ ██║    ██║     ██║  ██║██║  ██║╚██████╗   ██║   ╚██████╔╝██║  ██║███████╗
  9.   ╚══▀▀═╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═╝     ╚═╝    ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚══════╝
  10.  
  11.                                                                  PRESENTA
  12.                       _____________________________________________________________________________________________
  13.                         ,
  14.                        '|    |\/| _´_|_ _  _| _    _| _    /\  _ _    ´ _ _  _  _| _  _   /|~) _ |´ _  _  _  _  _\
  15.                        _|_.  |  |(/_ | (_)(_|(_)  (_|(/_  /~~\| (_||_||| | |(/_(_|(/__\  | |~ (_)||(_|(_)| |(_)_\ |
  16.                                                                   |                       \         _|           /
  17.  
  18.  Qué pasa chavales, muy buenas a todos, aquí Crespo comentando (xD willy pls). Con este código, escrito en C++, vamos a hacer que
  19.  este ordenador calcule pi utilizando el método que nuestro Antiguos usaban: calculando polígonos de lado 2*n (dos veces n).
  20.  Si quieres saber las ideas básicas de este algoritmo o no sabes como coj***s has llegado aquí y qué es este código
  21.  hablandome así wtf, te recomiendo pasarte por YouTube y verte este vídeo 
  22.  --> https://y...content-available-to-author-only...u.be/DQ5qqHukkAc   <--.
  23.  Vamos ahora a la miga: Imagina que tenemos DOS polígonos de "2n" lados: Uno inscrito dentro de una circunferencia de radio "r" 
  24.  (es decir, cuyos vertices tocan la circunferencia, está dentro del circulo) y otro circunscrito (es decir, cuyos lados tocan 
  25.  la circunferencia, están por fuera del circulo). 
  26.  En cualquier polígono siempre puedo tirar dos líneas desde el centro a dos vértices contiguos y formar un triángulo 
  27.  (el menor que se puede formar de esta manera):
  28.  
  29.   
  30.                                                           _____________________ (B)
  31.                                                           \     d   |         /
  32.                                                            \________|________/ h2
  33.                                                         (A) \   l   |       /
  34.                                                              \      |      /
  35.                                                               \     |r    /
  36.                                                             h1 \    |    /
  37.                                                                 \   |   /
  38.                                                                  \  |  /
  39.                                                                   \ | /
  40.                                                                    \ /  <----------- al ángulo del triángulo vamos a llamarlo "ang"
  41.                                                                     .
  42.                                                                   centro (O)
  43.  ...donde:
  44.     
  45.     * r   --> radio del circunferencia.
  46.     * h2  --> distancia centro-vertice (OB) del poligono que está CIRCUNSCRITO (que es el poligono está por fuera del círculo,
  47.              con los lados tocando la circunferencia).
  48.     * h1  --> distancia centro-vertice (OA) del polígono que está INSCRITO (que es el poligono está dentro del círculo,
  49.              con los vértices tocando la circunferencia).
  50.     * l   --> es la MITAD del lado del poligono interno.
  51.     * d   --> es la MITAD del lado del poligono externo.
  52.     * ang --> angulo formado por OA y OB. Si el poligono tiene n lados, entonces
  53.               sabemos cuanto vale: una vuelta completa son 2*pi, luego si tiene n lados,
  54.  
  55.                                                     ang = 2*pi/n
  56.  
  57.  Si no ves un carajo del gráfico te recomiendo que estires el tamaño de tu ventana, te llevarás una sorpresa --->
  58.  También es bastante recomendable que, si te quiere enterar bien de esto, te lo dibujes en un papel. Really.
  59.  
  60.  Dos definciones más: sea...
  61.  
  62.     * A_n --> el perímetro del polígono de n lados inscrito.
  63.     * B_n --> el perímetro del polígono de n lados cricunscrito.
  64.  
  65.  A las cuentas: vamos a calcular cuanto vale "l" y cuanto vale "d". Los necesitaremos para saber cuanto son los perímetros 
  66.  que es lo que buscamos, ohú. Por trigonometría básica (definición de seno), "l" verifica:
  67.  
  68.                                                    l = r * sin( pi/n )
  69.  
  70.  ... y "d" verifica:
  71.  
  72.                                                    d = r * tan( pi/n )
  73.  
  74.  Por lo tanto los respectivos perímetros serán el número de lados, n, por el lado, 2l y 2d respectivamente:
  75.  
  76.                   A_n = 2 * n * r * sin( pi/n )        B_n = 2 * n * r * tan( pi/n ) = A_n / cos(pi/n)
  77.  
  78.  Entonces, el perímetro de un polígono con el doble de lados debe verficar:
  79.  
  80.                   A_2n = 4 * n * r * sin( pi/2n )        B_2n = 4 * n * r * tan( pi/2n ) = A_2n / cos(pi/2n)
  81.  
  82.  El objetivo, ahora, es dejar A_2n y B_2n en función de A_n y B_n, es decir, que no dependamos de calcular ángulos (que
  83.  requieren de pi) para saber cuanto vale los perímetros. De este modo partiendo de un polígono muy sencillo cuyas dimensiones puedan
  84.  ser cálculados usando identidades trigonometricas muy sencillas, podemos ir generando los polígonos de más y más lados.
  85.  
  86.  No voy a escribir explicitamente como poner unos en función de los otros; es un desarrollo largo y tengo vídeos que hacer! Pero
  87.  si queréis intentarlo, usad todas las identidades trigonométricas que podáis, especialmente las del angulo doble y ángulo mitad ;)
  88.  
  89.  El resultado es:
  90.  
  91.                                                     B_2n = 2 * A_n * B_n / ( A_n + B_n )
  92.                                                     A_2n = raiz cuadrada de { A_n * B_2n }
  93.  
  94.  Dado que A se acerca al perimetro de la circunferencia desde valores menores y B desde valores mayores, podemos usar estos para 
  95.  calcular los errores del método. Es decir, que, una vez paremos en un cierto número de lados, tomaremos la media de ambos pi's 
  96.  calculados con los diferentes perímetros como el valor de este, y la diferencia de estos como el error que estamos comentiendo;
  97.  así tendremos el rango de valores en lo que el verdadero pi se encuentra.
  98.  
  99.  Quiero agradecer ENORMEMENTE a Diego Soler Polo por ayudarme a encontrar este algoritmo. Sin él, muchos aspectos de este vídeo
  100.  no serían posibles... y este código menos. 
  101.  
  102.  
  103. */
  104.  
  105.  
  106. #include <iostream>  // Cargo librerías (colecciones de funciones ya hechas que hacen cositas): "iostream" me permite sacar texto
  107. #include <cmath>     // y números por el terminal, para que puedas ver el valor de pi, y "cmath" es una colección de funciones
  108. #include <fstream>   // matemáticas que necesito, como elevar al cuadrado y hacer la raiz cuadrada.
  109.  
  110. using namespace std;  // A efectos práticos, esto es para no tener que poner "std" todo el rato.
  111.  
  112. int main(){           // ¡Comenzamos!
  113.  
  114.     // Imprimimos en el terminal... la bienvenida ;)
  115.  
  116.     cout<<endl<<endl;
  117.     cout<<"                       ╔═╗ ┬ ┬┌─┐┌┐┌┌┬┐┬ ┬┌┬┐  ╔═╗┬─┐┌─┐┌─┐┌┬┐┬ ┬┬─┐┌─┐"<<endl;
  118.     cout<<"                       ║═╬╗│ │├─┤│││ │ │ ││││  ╠╣ ├┬┘├─┤│   │ │ │├┬┘├┤"<<endl;
  119.     cout<<"                       ╚═╝╚└─┘┴ ┴┘└┘ ┴ └─┘┴ ┴  ╚  ┴└─┴ ┴└─┘ ┴ └─┘┴└─└─┘"<<endl;
  120.     cout<<"            ______________________________________________________________________     "<<endl<<endl;
  121.     cout<<"                                          PRESENTA...                                  "<<endl;
  122.     cout<<endl;
  123.     cout<<"              ╔═╗┌─┐┬  ┌─┐┬ ┬┬  ┌─┐  ┌┬┐┌─┐  ╔═╗┬       ╔═╗┌─┐┬  ┬┌─┐┌─┐┌┐┌┌─┐┌─┐"<<endl;
  124.     cout<<"              ║  ├─┤│  │  │ ││  │ │   ││├┤   ╠═╝│  ───  ╠═╝│ ││  ││ ┬│ │││││ │└─┐"<<endl;
  125.     cout<<"              ╚═╝┴ ┴┴─┘└─┘└─┘┴─┘└─┘  ─┴┘└─┘  ╩  ┴       ╩  └─┘┴─┘┴└─┘└─┘┘└┘└─┘└─┘"<<endl;
  126.  
  127.     cout<<endl<<"                       Dividiendo perímetros entre diametros desde 2017"<<endl<<endl;
  128.  
  129.     cout<<"_____________________________________________________________________________________________"<<endl<<endl;
  130.     cout<<"                                         ADVERTENCIA                                     "<<endl;
  131.     cout<<"Si está usando este código en un compilador online, puede ser que utilizar un número excesivo"<<endl;
  132.     cout<<" de lados haga que el cálculo necesite tanto tiempo para ser computado que el compilador lo"<<endl;
  133.     cout<<"               aborte automáticamente. En ese caso, pruebe un número menor."<<endl;
  134.  
  135.  
  136.     ////////////////////////////////////////////////////////////////////////////////////////////
  137.     ////////////////////////////////////////////////////////////////////////////////////////////
  138.     ////////////////////////////////////////////////////////////////////////////////////////////
  139.  
  140.     int n = 12345  ;         // NÚMERO DE LADOS DEL POLÍGONO. ¡CAMBIAD ESTO!
  141.  
  142.     ///////////////////////////////////////////////////////////////////////////////////////////
  143.     ///////////////////////////////////////////////////////////////////////////////////////////
  144.     //////////////////////////////////////////////////////////////////////////////////////////
  145.  
  146.     // Se expulsa tal número por terminal:
  147.  
  148.     cout<<endl<<"  ╔════════════════════════════════════════════════════════════════════════════════════════╗";
  149.     cout<<endl<<"  ║                 Número de lados máximo del polígono : "<<n;
  150.     cout<<endl<<"  ╚════════════════════════════════════════════════════════════════════════════════════════╝";
  151.  
  152.     double r=1;  // Este es RADIO DE LA CIRCUNFERENCIA. Puedes cambiarlo; el valor de pi no se ve afectado.
  153.  
  154.     double A;    // Defino los Perímetros de los polígonos inscritos y circunscritos.
  155.     double B;
  156.  
  157.     A=4*sqrt(2)*r;  // Cargo los perímetros de un CUADRADO inscrito (A) y circunscrito (B). Estos valores pueden ser fácilmente
  158.     B=8*r;          // obtenidos con el teorema de pitagoras, no pi required.
  159.  
  160.     double m=4;     // Este es el número de lados de los polígonos con los que estamos trabajando.
  161.  
  162.     while (m*2<=n) {  // BUCLE. Si el número de lados del polígono a generar supera el número impuesto por usuario, para.
  163.  
  164.         B=2*A*B/(A+B);      // Calculo de los perímetros con el doble de lados. A cada vuelta los valores de A y B se sobreeescriben.
  165.         A=sqrt(A*B);
  166.  
  167.         m=m*2;              // El número de lados se duplica en cada vuelta.
  168.  
  169.     }                 // Fin de BUCLE
  170.  
  171.     double pi=(  A/2/r + B/2/r  )/2;         // Calculamos pi como la media de los valores de pi de cada perimetro...
  172.     double err = abs(  A/2/r - B/2/r  )/2;   // ... y el error como la resta.
  173.  
  174.     cout.precision(15); // Estos son el número de digitos que quiero que se expulsen por pantalla. Puedes aumentarlo si quieres.
  175.  
  176.     // Sacamos los resultados por pantalla para disfrute del usuario:
  177.  
  178.     cout<<endl<<"  ╔════════════════════════════════════════════════════════════════════════════════════════╗";
  179.     cout<<endl<<"  ║                Con un polígono de "<<m<<" lados, obtenemos:";
  180.     cout<<endl<<"  ║";
  181.     cout<<endl<<"  ║                       "<<"Pi = "<<pi<<"  +/-  "<<err;
  182.     cout<<endl<<"  ║";
  183.     cout<<endl<<"  ║                "<<"o, dicho de otra manera, el valor de pi se encuentra entre";
  184.     cout<<endl<<"  ║                       "<<pi+err<<"   y   "<<pi-err;
  185.     cout<<endl<<"  ╚════════════════════════════════════════════════════════════════════════════════════════╝"<<endl<<endl;
  186.  
  187.  
  188.     return 0;  // Y hemos terminado. Cerramos el chiringuito.
  189.  
  190. }
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
Success #stdin #stdout 0s 5552KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 

                       ╔═╗ ┬ ┬┌─┐┌┐┌┌┬┐┬ ┬┌┬┐  ╔═╗┬─┐┌─┐┌─┐┌┬┐┬ ┬┬─┐┌─┐
                       ║═╬╗│ │├─┤│││ │ │ ││││  ╠╣ ├┬┘├─┤│   │ │ │├┬┘├┤
                       ╚═╝╚└─┘┴ ┴┘└┘ ┴ └─┘┴ ┴  ╚  ┴└─┴ ┴└─┘ ┴ └─┘┴└─└─┘
            ______________________________________________________________________     

                                          PRESENTA...                                  

              ╔═╗┌─┐┬  ┌─┐┬ ┬┬  ┌─┐  ┌┬┐┌─┐  ╔═╗┬       ╔═╗┌─┐┬  ┬┌─┐┌─┐┌┐┌┌─┐┌─┐
              ║  ├─┤│  │  │ ││  │ │   ││├┤   ╠═╝│  ───  ╠═╝│ ││  ││ ┬│ │││││ │└─┐
              ╚═╝┴ ┴┴─┘└─┘└─┘┴─┘└─┘  ─┴┘└─┘  ╩  ┴       ╩  └─┘┴─┘┴└─┘└─┘┘└┘└─┘└─┘

                       Dividiendo perímetros entre diametros desde 2017

_____________________________________________________________________________________________

                                         ADVERTENCIA                                     
Si está usando este código en un compilador online, puede ser que utilizar un número excesivo
 de lados haga que el cálculo necesite tanto tiempo para ser computado que el compilador lo
               aborte automáticamente. En ese caso, pruebe un número menor.

  ╔════════════════════════════════════════════════════════════════════════════════════════╗
  ║                 Número de lados máximo del polígono : 12345
  ╚════════════════════════════════════════════════════════════════════════════════════════╝
  ╔════════════════════════════════════════════════════════════════════════════════════════╗
  ║                Con un polígono de 8192 lados, obtenemos:
  ║
  ║                       Pi = 3.14159269209226  +/-  1.15507386100333e-07
  ║
  ║                o, dicho de otra manera, el valor de pi se encuentra entre
  ║                       3.14159280759965   y   3.14159257658487
  ╚════════════════════════════════════════════════════════════════════════════════════════╝
https://ideone.com/qe6dUP
language:
C++ (gcc 8.3)
created:
2 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!