commit 40e2b29d95dd6c87d41637b01ff23324a083da8d Author: g.mandl Date: Wed Oct 22 23:12:23 2025 +0200 Dateien nach „BSP_1_F“ hochladen diff --git a/BSP_1_F/bsp_1_f.cbp b/BSP_1_F/bsp_1_f.cbp new file mode 100644 index 0000000..150725c --- /dev/null +++ b/BSP_1_F/bsp_1_f.cbp @@ -0,0 +1,43 @@ + + + + + + diff --git a/BSP_1_F/bsp_1_f.cpp b/BSP_1_F/bsp_1_f.cpp new file mode 100644 index 0000000..9ad0b0d --- /dev/null +++ b/BSP_1_F/bsp_1_f.cpp @@ -0,0 +1,44 @@ +#include "bsp_1_f.h" +#include "mayer_primes.h" +#include "algorithm" +#include + +using namespace std; + +int single_goldbach(const int &k) +{ + vector primes = get_primes(k); + int amount = 0; + for(size_t it = 0; primes[it]<=k/2.0; ++it) //für Primzahl größer als k/2 haben wir bereits Zerlegung gezählt: 3+7 = 7+3 + { + for(size_t j = it; j count_goldbach(const int &n) +{ + vector count_vec((n-4)/2+1,0); + vector primes = get_primes(n); + for(size_t k=0; k < primes.size() && primes[k]<=n/2; ++k) + { + for(size_t i=k; i + +/** \brief Zaehlt fuer eine gegebene Zahl @k die Anzahl der moeglichen Zerlegungen als Summe zweier Primzahlen + * + * \param[in] k fuer diese Zahl wird die Anzahl der Zerlegungen berechnet + * \return Anzahl der Zerlegungen + * + */ +int single_goldbach(const int &k); + +/** \brief Zaehlt die Anzahl der Dekomposition für alle geraden Zahlen in [4,n] + * + * \param[in] n obere Intervallgrenze (in diesem Bereich werden die Dekompositionen berechnet + * \return Vektor mit den Anzahl der Dekompositionen (ad Adressierung: x[0] = (n=4), x[1] = (n=6), x[2] = (n=8), Umrechnung *2 + 4 + * + */ +std::vector count_goldbach(const int &n); +#endif // BSP_1_F_H_INCLUDED diff --git a/BSP_1_F/main.cpp b/BSP_1_F/main.cpp new file mode 100644 index 0000000..23b63a4 --- /dev/null +++ b/BSP_1_F/main.cpp @@ -0,0 +1,31 @@ +#include "bsp_1_f.h" +#include "mayer_primes.h" +#include +#include +#include +// BSP 1_F +using namespace std; + +int main() +{ + // Auswertung für n=100000 bzw herausfinden der Zahl, welche die meisten Dekompositionen hat + vector v = count_goldbach(1e5); + auto ip = max_element(v.begin(), v.end()); + cout << "Zahl zwischen [4,1e5] mit meisten Zerlegungen" << endl; + cout << "Zahl k " << distance(v.begin(), ip)*2+4 << " mit " << *ip << " Zerlegungen" << endl; + + cout << "Zeitmessungen" << endl; + vector nvec{static_cast(1e4), static_cast(1e5), static_cast(4*1e5), static_cast(1e6), static_cast(2*1e6)}; // Vektor für n + for(size_t k=0; k vall = count_goldbach(nvec[k]); + auto timeend = chrono::system_clock::now(); + auto time = chrono::duration_cast(timeend - timestart); + cout << "n = " << nvec[k] << " time: " << time.count() << " ms" << endl << endl; + } + +// cout << single_goldbach(694) << endl; +// cout << count_goldbach(10000)[690/2] << endl; + return 0; +} diff --git a/BSP_1_F/mayer_primes.h b/BSP_1_F/mayer_primes.h new file mode 100644 index 0000000..6c6dc23 --- /dev/null +++ b/BSP_1_F/mayer_primes.h @@ -0,0 +1,73 @@ +#pragma once + +#include //memset +#include +//using namespace std; + +/** \brief Determines all prime numbers in interval [2, @p max]. + * + * The sieve of Eratosthenes is used. + * + * The implementation originates from Florian Mayer. + * + * \param[in] max end of interval for the prime number search. + * \return vector of prime numbers @f$2,3,5, ..., p<=max @f$. + * + * \copyright + * Copyright (c) 2008 Florian Mayer (adapted by Gundolf Haase 2018) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +template +std::vector get_primes(T max) +{ + std::vector primes; + char *sieve; + sieve = new char[max / 8 + 1]; + // Fill sieve with 1 + memset(sieve, 0xFF, (max / 8 + 1) * sizeof(char)); + for (T x = 2; x <= max; x++) + { + if (sieve[x / 8] & (0x01 << (x % 8))) { + primes.push_back(x); + // Is prime. Mark multiplicates. + for (T j = 2 * x; j <= max; j += x) + { + sieve[j / 8] &= ~(0x01 << (j % 8)); + } + } + } + delete[] sieve; + return primes; +} + +//--------------------------------------------------------------- +//int main() // by Florian Mayer +//{g++ -O3 -std=c++14 -fopenmp main.cpp && ./a.out +// vector primes; +// primes = get_primes(10000000); +// // return 0; +// // Print out result. +// vector::iterator it; +// for(it=primes.begin(); it < primes.end(); it++) +// cout << *it << " "; +// +// cout << endl; +// return 0; +//}