Разделить и получить остаток одновременно?

StackOverflow https://stackoverflow.com/questions/3895081

  •  29-09-2019
  •  | 
  •  

Вопрос

По-видимому, x86 (и, вероятно, множество других наборов команд) помещают как частное, так и оставшуюся часть операции разделения в отдельные регистры.

Теперь мы, вероятно, можем доверить компиляторам оптимизировать такой код, как этот, чтобы использовать только один вызов для разделения:

( x / 6 )
( x % 6 )

И они, вероятно, так и делают.Тем не менее, делайте какие-либо языки (или библиотеки, но в основном ищущие языки) поддерживают одновременное получение результатов как по делению, так и по модулю?Если да, то что это такое и как выглядит синтаксис?

Это было полезно?

Решение

C имеет div и ldiv. Анкет Создают ли они отдельные инструкции для коэффициента и остатка, будут зависеть от вашей конкретной стандартной реализации библиотеки и настройки компилятора и оптимизации. Начиная с C99, у вас также есть lldiv для больших чисел.

Другие советы

Питон делает.

>>> divmod(9, 4)
(2, 1)

Что странно, Becuase Python - это такой язык высокого уровня.

Так это рубин:

11.divmod(3) #=> [3, 2]

* РЕДАКТИРОВАТЬ *

Следует отметить, что цель этих операторов, вероятно, не состоит в том, чтобы выполнять работу максимально эффективно, а более вероятно, что функции существуют по причинам правильности/переносимости.

Для тех, кто заинтересован, я верю Это код реализации Python для Integer divmod:

static enum divmod_result
i_divmod(register long x, register long y,
     long *p_xdivy, long *p_xmody)
{
long xdivy, xmody;

if (y == 0) {
    PyErr_SetString(PyExc_ZeroDivisionError,
                    "integer division or modulo by zero");
    return DIVMOD_ERROR;
}
/* (-sys.maxint-1)/-1 is the only overflow case. */
if (y == -1 && UNARY_NEG_WOULD_OVERFLOW(x))
    return DIVMOD_OVERFLOW;
xdivy = x / y;
/* xdiv*y can overflow on platforms where x/y gives floor(x/y)
 * for x and y with differing signs. (This is unusual
 * behaviour, and C99 prohibits it, but it's allowed by C89;
 * for an example of overflow, take x = LONG_MIN, y = 5 or x =
 * LONG_MAX, y = -5.)  However, x - xdivy*y is always
 * representable as a long, since it lies strictly between
 * -abs(y) and abs(y).  We add casts to avoid intermediate
 * overflow.
 */
xmody = (long)(x - (unsigned long)xdivy * y);
/* If the signs of x and y differ, and the remainder is non-0,
 * C89 doesn't define whether xdivy is now the floor or the
 * ceiling of the infinitely precise quotient.  We want the floor,
 * and we have it iff the remainder's sign matches y's.
 */
if (xmody && ((y ^ xmody) < 0) /* i.e. and signs differ */) {
    xmody += y;
    --xdivy;
    assert(xmody && ((y ^ xmody) >= 0));
}
*p_xdivy = xdivy;
*p_xmody = xmody;
return DIVMOD_OK;
}

В C#/. Net у вас есть Math.DivRem: http://msdn.microsoft.com/en-us/library/system.math.divrem.aspx.

Но согласно эта ветка Это не такая оптимизация.

Как упомянул Стрингер Белл DivRem который не оптимизирован до .NET 3.5.

На .net 4.0 он использует ngen.

Результаты, с которыми я получил Math.DivRem (Debug; Release = ~ 11000ms)

11863
11820
11881
11859
11854

Результаты я получил с MyDivRem (Debug; Release = ~ 11000ms)

29177
29214
29472
29277
29196

Проект, предназначенный для X86.

Math.DivRem Пример использования

int mod1;
int div1 = Math.DivRem(4, 2, out mod1);

Метод подписи

DivRem(Int32, Int32, Int32&) : Int32
DivRem(Int64, Int64, Int64&) : Int64

.Net 4.0 код

[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
public static int DivRem(int a, int b, out int result)
{
    result = a % b;
    return (a / b);
}

.Net 4.0 IL.

.custom instance void System.Runtime.TargetedPatchingOptOutAttribute::.ctor(string) = { string('Performance critical to inline across NGen image boundaries') }
.maxstack 8
L_0000: ldarg.2 
L_0001: ldarg.0 
L_0002: ldarg.1 
L_0003: rem 
L_0004: stind.i4 
L_0005: ldarg.0 
L_0006: ldarg.1 
L_0007: div 
L_0008: ret

MSDN Ссылка

Платформа .NET Framework имеет Math.DivRem:

int mod, div = Math.DivRem(11, 3, out mod);
// mod = 2, div = 3

Хотя, DivRem это просто обертка вокруг чего-то подобного:

int div = x / y;
int mod = x % y;

(Я понятия не имею, может ли джиттер оптимизировать подобные вещи в одну инструкцию.)

FWIW, Haskell имеет оба divMod и quotRem что последнее из которых непосредственно соответствует инструкции машины (согласно Интегральные операторы quot vs. div) пока divMod может нет.

    int result,rest;
    _asm
    {
        xor edx, edx // pone edx a cero; edx = 0
        mov eax, result// eax = 2AF0
        mov ecx, radix // ecx = 4
        div ecx
        mov val, eax
        mov rest, edx
    }

Это возвращает результат до конца 

        int result,rest;
    _asm
    {
        xor edx, edx // pone edx a cero; edx = 0
        mov eax, result// eax = 2AF0
        mov ecx, radix // ecx = 4
        div ecx
        mov val, eax
        mov rest, edx
    }

В Java класс BigDecimal имеет операцию divideAndRemainder Возвращая массив из 2 элементов с результатом и остаток отдела подразделения.

BigDecimal bDecimal = ...
BigDecimal[] result = bDecimal.divideAndRemainder(new BigDecimal(60));

Javadoc: https://docs.orcle.com/javase/7/docs/api/java/math/bigdecimal.html#divideandremainder(java.math.bigdecimal)

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top