Python-Stil integer-division & E-Modul in C

Richtung zur Rundung mit vorzeichenbehafteten integer-division ist, die nicht in älteren C-Normen. Aber in C99 spezifiziert Runden in Richtung null.

Hier der portable code, der funktioniert mit allen Versionen des C-standards und CPU-Architekturen:

int py_div(int a, int b)
{
  if (a < 0)
    if (b < 0)
      return -a / -b;
    else
      return -(-a / b) - (-a % b != 0 ? 1 : 0);
  else if (b < 0)
      return -(a / -b) - (a % -b != 0 ? 1 : 0);
    else
      return a / b;
}

int py_mod(int a, int b)
{
  if (a < 0)
    if (b < 0)
      return -(-a % -b);
    else
      return -a % b - (-a % -b != 0 ? 1 : 0);
  else if (b < 0)
      return -(a % -b) + (-a % -b != 0 ? 1 : 0);
    else
      return a % b;
}

Habe ich einige oberflächliche tests und es scheint, die gleichen Ergebnisse wie Python. Dieser code kann nicht maximal effizient, aber ein guter C-compiler kann wahrscheinlich optimieren Sie ausreichend, vor allem, wenn Sie den code im header als static-Funktionen.

Können Sie auch wollen, um einen Blick auf das eng damit verbundene Frage: Integer-division Rundung bei negativen in C++.

Hier ist eine einfache Implementierung von umgehauen, division und modulus in C89:

#include <stdlib.h>

div_t div_floor(int x, int y)
{
    div_t r = div(x, y);
    if (r.rem && (x < 0) != (y < 0)) {
        r.quot -= 1;
        r.rem  += y;
    }
    return r;
}

Hier div wird verwendet, weil es hat gut definiert Verhalten.

Wenn Sie C++11, hier ist eine vorgefertigte Implementierung von umgehauen, division und modulus:

#include <tuple>

template<class Integral>
std::tuple<Integral, Integral> div_floor(Integral x, Integral y)
{
    typedef std::tuple<Integral, Integral> result_type;
    const Integral quot = x / y;
    const Integral rem  = x % y;
    if (rem && (x < 0) != (y < 0))
        return result_type(quot - 1, rem + y);
    return result_type(quot, rem);
}

In C99 und C++11, können Sie verhindern, indem div da das Verhalten der division und modulus in C sind nicht mehr abhängig von der Implementierung.

Die Frage, gefragt, wie emulieren Python-Stil integer-division und modulo. Alle Antworten die hier gegeben werden, übernehmen die Operanden der operation auf ganze zahlen selbst, sondern in Python können auch Schwimmer für seine modulo-operation. So, ich denke, die folgende Antwort löst das problem noch besser:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

int pydiv(double a, double b) {
    int q = a/b;
    double r = fmod(a,b);
    if ((r != 0) && ((r < 0) != (b < 0))) {
        q -= 1;
    }
    return q;
}

int main(int argc, char* argv[])
{
    double a = atof(argv[1]);
    double b = atof(argv[2]);
    printf("%d\n", pydiv(a, b));
}

Sowie für den modulo:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

double pymod(double a, double b) {
    double r = fmod(a, b);
    if (r!=0 && ((r<0) != (b<0))) {
        r += b;
    }
    return r;
}

int main(int argc, char* argv[])
{
    double a = atof(argv[1]);
    double b = atof(argv[2]);
    printf("%f\n", pymod(a, b));
}

Getestet habe ich die beiden oben genannten Programme vor, wie Python verhält sich mit den folgenden test-code:

#!/usr/bin/python3
import subprocess
subprocess.call(["cc", "pydiv.c", "-lm", "-o", "cdiv"])
subprocess.call(["cc", "pymod.c", "-lm", "-o", "cmod"])
def frange(start, stop, step=1):
    for i in range(0, int((stop-start)/step)):
        yield start + step*i
for a in frange(-10.0, 10.0, 0.25):
    for b in frange(-10.0, 10.0, 0.25):
        if (b == 0.0):
            continue
        pydiv = a//b
        pymod = a%b
        cdiv = int(subprocess.check_output(["./cdiv", str(a), str(b)]))
        cmod = float(subprocess.check_output(["./cmod", str(a), str(b)]))
        if pydiv != cdiv:
            exit(1)
        if pymod != cmod:
            exit(1)

Den oben genannten vergleichen das Verhalten von Python-division und modulo mit der C
Implementierungen stellte ich auf 6320 testcases. Da der Vergleich erfolgreich war,
Ich glaube, dass meine Lösung richtig implementiert Python Verhalten von
jeweiligen Operationen.