Výpočet pí na 40 míst

[Diego]

Jeden nejmenovaný člen fóra chtěl napsat program pro Arduino který spočítá číslo pí na 40 desetiných míst. Sice nevím k čemu mu to bude ale tady ho máš. Arduino UNO ho vypočítá za 266.6 ms.
Program nejdřív provede výpočet a potom výpis s dobou výpočtu v ms a us. Můžete ho zkusit třeba jako benchmark více desek, mělo by to běžet i na ESP. Jinak benchmark MCU jsem dělal taky a lepší, ten vyjde 19.9.
Tady je kód:

Kód: Vybrat vše

/*
  Výpočet čísla pí na 40 desetinných míst
  a změření doby samotného výpočtu.

  Vhodné pro Arduino UNO, Nano, Mega, ESP32 a další.
*/

constexpr uint8_t DECIMAL_PLACES = 40;

// Jedna číslice před desetinnou čárkou + desetinná místa
constexpr uint16_t PI_DIGITS = DECIMAL_PLACES + 1;

// Velikost pracovního pole pro spigot algoritmus
constexpr uint16_t WORK_SIZE = PI_DIGITS * 10 / 3 + 1;

uint16_t workArray[WORK_SIZE];

// Výsledek obsahuje pomocnou úvodní nulu,
// číslice pí a ukončovací znak
char piRaw[PI_DIGITS + 2];

void appendDigit(uint8_t digit, uint16_t &position)
{
  piRaw[position++] = '0' + digit;
}

void calculatePi()
{
  for (uint16_t i = 0; i < WORK_SIZE; i++) {
    workArray[i] = 2;
  }

  uint16_t position = 0;
  uint16_t predigit = 0;
  uint16_t nines = 0;

  for (uint16_t digit = 0; digit < PI_DIGITS; digit++) {
    uint32_t q = 0;

    for (int i = WORK_SIZE; i > 0; i--) {
      uint32_t x = 10UL * workArray[i - 1] + q * i;

      workArray[i - 1] = x % (2 * i - 1);
      q = x / (2 * i - 1);
    }

    workArray[0] = q % 10;
    q /= 10;

    if (q == 9) {
      nines++;
    }
    else if (q == 10) {
      appendDigit(predigit + 1, position);

      while (nines > 0) {
        appendDigit(0, position);
        nines--;
      }

      predigit = 0;
    }
    else {
      appendDigit(predigit, position);
      predigit = q;

      while (nines > 0) {
        appendDigit(9, position);
        nines--;
      }
    }
  }

  appendDigit(predigit, position);
  piRaw[position] = '\0';
}

void setup()
{
  Serial.begin(115200);

  // U některých desek počká na otevření sériového portu
  // maximálně dvě sekundy.
  uint32_t serialStart = millis();

  while (!Serial && millis() - serialStart < 2000) {
  }

  Serial.println();
  Serial.println(F("Vypocet cisla pi na 40 desetinnych mist"));
  Serial.println(F("---------------------------------------"));

  uint32_t startTime = micros();

  calculatePi();

  uint32_t calculationTime = micros() - startTime;

  Serial.print(F("pi = "));

  // Přeskočení pomocné úvodní nuly
  Serial.print(piRaw[1]);
  Serial.print('.');

  for (uint16_t i = 2; i <= PI_DIGITS; i++) {
    Serial.print(piRaw[i]);
  }

  Serial.println();

  Serial.print(F("Doba vypoctu: "));
  Serial.print(calculationTime);
  Serial.println(F(" us"));

  Serial.print(F("Doba vypoctu: "));
  Serial.print(calculationTime / 1000.0, 3);
  Serial.println(F(" ms"));
}

void loop()
{
}

[AstroMiK]

Hezký.
Matematicky to teda nechápu, ale udělal jsem testy na třech STM32Fxxx a tady jsou výsledky:

BlackPill (STM32F411CEU)
Vypocet cisla pi na 40 desetinnych mist
---------------------------------------
pi = 3.1415926535897932384626433832795028841971
Doba vypoctu: 999 us
Doba vypoctu: 0.999 ms



BlackPill (STM32F401CEU)
Vypocet cisla pi na 40 desetinnych mist
---------------------------------------
pi = 3.1415926535897932384626433832795028841971
Doba vypoctu: 1144 us
Doba vypoctu: 1.144 ms



BluePill (STM32F103)
Vypocet cisla pi na 40 desetinnych mist
---------------------------------------
pi = 3.1415926535897932384626433832795028841971
Doba vypoctu: 1926 us
Doba vypoctu: 1.926 ms

-------
EDIT:
Ty dva BlackPilly jsem si přesměroval na jiný sériový port, ale to by nemělo mít na výpočet vliv:

Kód: Vybrat vše

HardwareSerial Serial1(PA10, PA9);
#define Serial Serial1 

[Diego]

Pěkný, trošku lepší výkon než UNO

[kiRRow]

A ten kód jsi napsal ty, nebo umělá inteligence ? ... né že bych se v tom chtěl vrtat, je to funkční řešení zadaného problému ... ale zajímaly by mě nástroje a metoda, kterou jsi k řešení dospěl

[Diego]

GPT V tomhle se fakt nevyznam Ale jak řikáš, je to funkční řešení

[gilhad]

Zkoušel jsem si představit, k čemu se dá takhle přesné pí použít. Například se s ním dá na atom přesně spočítat obvod kružnice obsahující celý pozorovatelný vesmír

[kiRRow]

Já se na základní škole naučil Pí na 10míst ... vycházeli mi pak jiné výsledky než ostatním, přesnější ... a učitelku matematiky jsem tím doháněl k šílenství

[Diego]

Taky dobrý

[gilhad]

Já se ho na střední naučil asi na 20 míst, protože jsme měli na dílnách takového vzteklého dědka, co nesnášel zaokrouhlování.

Takže když mě pak vyvolal k tabuli a dal mi cosi spočítat, tak jsem začal, že "blabla bla 2 pí eF, pí, to je tak asi přibližně 3, " a on okamžitě vyletěl, že "tři? jaký tři? to to přesněji neznáte?" a já řekl "ale jistě" a napsal jsem ho na tabuli na 11 míst (abych měl rezervu, kdyby špičkoval ve smyslu "a to je všechno?", jenže to už neudělal)

Načež jsem ve výpočtu jako F použil 50 Hz, které jsme měli používat místo naměřených 48.75 Hz, aby výsledky byly podle tabulky ...

takže kdybych použil pí=3, byl bych správnému výsledku blíž, než s přesnější hodnotou