Das deutsche Python-Forum

Code: Alles auswählen

from mpmath import mp
import time

mp.dps = 1000000
euler = 1
x = 1
n = 1
i = 0

zeit1 = (time.strftime("%d.%m.%Y %H:%M:%S:%MS"))
test = time.clock()
while n < 200000:
    x = mp.fmul(x,n)
    euler = euler + mp.fdiv(1,x)
    n = n + 1  
    
    if time.clock() - test  > 1800:
        
        f = open("tmp.txt","w")
        f.truncate()
        f.write(str(euler))
        f.close()
        test = time.clock()


print(euler)
euler2 = euler + mp.fdiv(1,x*n)
print(euler2)

zeit2 =(time.strftime("%d.%m.%Y %H:%M:%S:%MS")) 

eulerdiv = 0
eulerdiv = mp.fsub(euler2,euler)
print(eulerdiv)

if eulerdiv > 0:
    while eulerdiv < 0.1:
        eulerdiv = eulerdiv * 10
        i += 1
    print(i)
    
    
zeit2 =(time.strftime("%d.%m.%Y %H:%M:%S:%MS"))    
print(zeit1)
print(zeit2)

Code: Alles auswählen

import decimal
import sys
import time


def euler_fraction(N):
    numerator = denominator = 1
    
    for i in xrange(1, N):
        numerator = i*numerator + 1
        denominator *= i
    
    return numerator, denominator


def main():
    N = 205211
    PRECISION = 1000000
    
    filename = sys.argv[1]
    
    start = time.time()
    numerator, denominator = map(decimal.Decimal, euler_fraction(N))
    
    decimal.getcontext().prec = PRECISION
    with open(filename, "w") as fp:
        fp.write(str(numerator/denominator))
    
    end = time.time()
    
    print "total:", end - start, "seconds"
    

if __name__ == "__main__":
    main()

Code: Alles auswählen

#include <iostream>
#include <fstream>

#include <boost/multiprecision/gmp.hpp>


typedef boost::multiprecision::mpf_float Float;
typedef boost::multiprecision::mpz_int Int;
typedef boost::multiprecision::mpq_rational Rational;


Rational euler_fraction(
    const unsigned int n)
{
    Int numerator = 1;
    Int denominator = 1;
    
    for(unsigned int i=1; i<n; ++i) {
        numerator = numerator*i + 1;
        denominator *= i;
    }
    
    return Rational(numerator, denominator);
}


int main(
    int argc,
    char **argv)
{
    static const unsigned int PRECISION = 1000000;
    static const unsigned int N = 205211;
    
    Float::default_precision(PRECISION);
    
    std::ofstream stream(argv[1]);
    stream.precision(PRECISION);
    stream << Float(euler_fraction(N));
    stream.close();
    
    return 0;
}

Code: Alles auswählen

import multiprocessing as mp
import operator

def calculate_numerator(N, result):
    numerator = 1
    
    for i in xrange(1, N):
        numerator = i*numerator + 1
    
    result.put(numerator)


def calculate_numerator2(N, result):
    result.put(reduce(operator.mul, xrange(1, N)))


def calculate_denominator(N, result):
    denominator = 1
    
    for i in xrange(1, N):
        denominator *= i
    
    result.put(denominator)


def calculate_denominator2(N, result):
    result.put(math.factorial(N))


def euler_parallel(N):
    numerator = mp.Queue()
    denominator = mp.Queue()
    
    pn = mp.Process(target=calculate_numerator2, args=(N, numerator))
    pd = mp.Process(target=calculate_denominator2, args=(N, denominator))
    
    pn.start()
    pd.start()
    
    return numerator.get(), denominator.get()

Code: Alles auswählen

from mpmath import mp
from math import log10, factorial
import time
from multiprocessing import Process, Queue

  
def get_p(n, queue):
    print("get_p ...")
    p = 1
    for i in range(1, n+1):
        p = i*p + 1
    queue.put(p)
    print("get_p done!")
     
def get_q(n, queue):
    print("get_q ...")
    q = factorial(n)
    queue.put(q)
    print("get_q done!")
  
def get_p_q_multiprocess(n):
    p_queue = Queue()
    q_queue = Queue()

    p_process = Process(target=get_p, args=(n, p_queue))
    q_process = Process(target=get_q, args=(n, q_queue))

    p_process.start()
    q_process.start()

    q = q_queue.get()
    p = p_queue.get()

    q_process.join()
    p_process.join()
    
    return p, q
    
def main():
    
    n = 1*10**4
    
    t1 = time.time()
    p, q = get_p_q_multiprocess(n)
    t2 = time.time()
    
    print("calc p and q in"(t2-t1))

    p_mag_10 = int(log10(p))+1
    prec = p_mag_10
    print("precicion:", prec)
    

    mp.dps = prec + 10
    
    time3 = time.time()
    euler = mp.fdiv(p, q)
    time4 = time.time()
    print(time4 - time3)


    s = str(euler)[:prec+1]
    print(s[3])    

main()

Code: Alles auswählen

let one = Gmp.F.from_int 1
let prec = 1_000_000
let fmul = Gmp.F.mul_prec_ui ~prec
let fdiv = Gmp.F.div_prec ~prec
let fadd = Gmp.F.add_prec ~prec
let to_string = Gmp.F.to_string_base_digits ~base:10 ~digits:1000

let f () =
  let x = ref one in
  let euler = ref one in
  for n = 1 to 205_211 do
    x := fmul !x n;
    euler := fadd !euler @@ fdiv one !x;
  done;
  print_endline @@ to_string !euler

let _ =
  f ()

Code: Alles auswählen

#include <iostream>
#include <fstream>
#include <thread>

#include <boost/multiprecision/gmp.hpp>


typedef boost::multiprecision::mpf_float Float;
typedef boost::multiprecision::mpz_int Int;
typedef boost::multiprecision::mpq_rational Rational;


void numerator_thread(
    const unsigned int n,
    Int & numerator)
{
    numerator = 1;
    
    for(unsigned int i=1; i<n; ++i) {
        numerator = numerator*i + 1;
    }
}


void denominator_thread(
    const unsigned int n,
    Int & denominator)
{
    denominator = 1;
    
    for(unsigned int i=1; i<n; ++i) {
        denominator *= i;
    }
}


Rational euler_parallel(
    const unsigned int n)
{
    Int numerator = 1;
    Int denominator = 1;
    
    std::thread nt(&numerator_thread, n, std::ref(numerator));
    std::thread dt(&denominator_thread, n, std::ref(denominator));
    
    nt.join();
    dt.join();
    
    return Rational(numerator, denominator);
}


int main(
    int argc,
    char **argv)
{
    static const unsigned int PRECISION = 1000000;
    static const unsigned int N = 205211;
    
    Float::default_precision(PRECISION);
    
    std::ofstream stream(argv[1]);
    stream.precision(PRECISION);
    stream << Float(euler_parallel(N));
    stream.close();
    
    return 0;
}

Code: Alles auswählen

from mpmath import mp

mp.dps = 1000000
euler = 1
x = 1
n = 1

while n < 205211:
    x = mp.fmul(x,n)
    euler = euler + mp.fdiv(1,x)
    n = n + 1

print(euler)