PHP vs python, problème de performance en php

Question

Il existe un algorithme pour la factorisation des nombres premiers en python. Il s'exécute en environ 10 millisecondes pour un grand nombre entier. Je l'ai réécrit pour php. Aussi pour de très grands entiers j'ai utilisé bc et gmp fonctions en php. Le résultat est très lent et prend environ 4 secondes pour la même entrée!

Voici mon code:

(REMARQUE: les fonctions dans la fonction principale sont testés séparément et ils sont très rapides)

public function primefactors($n, $sort = false) { 


    $smallprimes = $this->primesbelow(10000); 
    $factors = []; 

    // NOTE: bc or gmp functions is used for big numbers calculations 
    $limit = bcadd(bcsqrt($n) , 1); 
    foreach ($smallprimes as $checker) { 
     if ($checker > $limit) { 
      break; 
     } 
     // while (gmp_mod($n, $checker) == 0) { 
     // while ($n%$checker == 0) { 
     while (bcmod($n, $checker) == 0) { 
      array_push($factors, $checker); 
      // $n = (int)($n/$checker); 
      $n = bcdiv($n, $checker); 
      // $limit = (int)(bcpow($n, 0.5)) + 1; 
      $limit = bcadd(bcsqrt($n) , 1); 
      if ($checker > $limit) { 
       break; 
      } 
     } 
    } 

    if ($n < 2) { 
     return $factors; 
    } 

    while ($n > 1) { 
     if ($this->isprime($n)) { 
      array_push($factors, $n); 
      // var_dump($factors); 
      break; 
     } 
     $factor = $this->pollard_brent($n); 
     $factors = array_merge($factors, $this->primefactors($factor)); 
     $n = (int)($n/$factor); 
    } 
    if ($sort) { 
     sort($factors); 
    } 

    return $factors; 

} 

Y at-il problème de performance dans mon code ?? Ou php lui-même a un problème de performance? Pourquoi python est si rapide? (environ 40 fois plus rapide)

Edit: Voici le code python:

smallprimes = primesbelow(10000) # might seem low, but 1000*1000 = 1000000, so this will fully factor every composite < 1000000 
def primefactors(n, sort=False): 
    factors = [] 

    limit = int(n ** .5) + 1 
    for checker in smallprimes: 
     if checker > limit: break 
     while n % checker == 0: 
      factors.append(checker) 
      n //= checker 
      limit = int(n ** .5) + 1 
      if checker > limit: break 

    if n < 2: return factors 

    while n > 1: 
     if isprime(n): 
      factors.append(n) 
      break 
     factor = pollard_brent(n) # trial division did not fully factor, switch to pollard-brent 
     factors.extend(primefactors(factor)) # recurse to factor the not necessarily prime factor returned by pollard-brent 
     n //= factor 

    if sort: factors.sort() 

    return factors 

Answer 1

Cocher cette benchmarks https://blog.famzah.net/2016/02/09/cpp-vs-python-vs-perl-vs-php-performance-benchmark-2016/

Vous demandez pourquoi un turttle est plus lent qu'un cheval fait le même circuit .