Логарифмически разнесенные целые числа

Ответ 1

Это немного сложно. Вы не всегда можете получить логарифмически разнесенные числа. Как и в вашем примере, первая часть довольно линейна. Если у вас все в порядке, у меня есть решение. Но для решения вы должны понять, почему у вас есть дубликаты.

Логарифмическая шкала удовлетворяет условию:

s[n+1]/s[n] = constant

Позвольте называть эту константу r для ratio. Для n этих чисел между диапазоном 1...size вы получите:

1, r, r**2, r**3, ..., r**(n-1)=size

Итак, это дает вам:

r = size ** (1/(n-1))

В вашем случае n=100 и size=10000, r будет ~1.0974987654930561, что означает, что если вы начинаете с 1, ваш следующий номер будет 1.0974987654930561, который затем округляется до 1 снова. Таким образом, ваши дубликаты. Этот вопрос присутствует для небольших номеров. После достаточно большого числа умножение с отношением приведет к другому округленному целому числу.

Помня об этом, лучше всего добавить последовательные целые числа до определенной точки, чтобы это умножение с отношением больше не было проблемой. Затем вы можете продолжить логарифмическое масштабирование. Следующая функция делает это:

import numpy as np

def gen_log_space(limit, n):
    result = [1]
    if n>1:  # just a check to avoid ZeroDivisionError
        ratio = (float(limit)/result[-1]) ** (1.0/(n-len(result)))
    while len(result)<n:
        next_value = result[-1]*ratio
        if next_value - result[-1] >= 1:
            # safe zone. next_value will be a different integer
            result.append(next_value)
        else:
            # problem! same integer. we need to find next_value by artificially incrementing previous value
            result.append(result[-1]+1)
            # recalculate the ratio so that the remaining values will scale correctly
            ratio = (float(limit)/result[-1]) ** (1.0/(n-len(result)))
    # round, re-adjust to 0 indexing (i.e. minus 1) and return np.uint64 array
    return np.array(list(map(lambda x: round(x)-1, result)), dtype=np.uint64)

Обновление Python 3: Последняя строка была return np.array(map(lambda x: round(x)-1, result), dtype=np.uint64) в Python 2

Вот несколько примеров использования:

In [157]: x = gen_log_space(10000, 100)

In [158]: x.size
Out[158]: 100

In [159]: len(set(x))
Out[159]: 100

In [160]: y = gen_log_space(2000, 50)

In [161]: y.size
Out[161]: 50

In [162]: len(set(y))
Out[162]: 50

In [163]: y
Out[163]:
array([   0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   11,
         13,   14,   17,   19,   22,   25,   29,   33,   38,   43,   49,
         56,   65,   74,   84,   96,  110,  125,  143,  164,  187,  213,
        243,  277,  316,  361,  412,  470,  536,  612,  698,  796,  908,
       1035, 1181, 1347, 1537, 1753, 1999], dtype=uint64)

И просто, чтобы показать вам, как выглядят логарифмические результаты, вот полулогарифмический вывод вывода для x = gen_log_scale(10000, 100) (как вы можете видеть, левая часть на самом деле не логарифмическая):

Ответ 2

Подход в Ответ Avaris о создании ваших точек в лог-центрах напрямую, определенно, путь. Но я подумал, что было бы интересно посмотреть, как выбрать подходящее значение для перехода на logspace, чтобы получить то, что вы хотите.

Значения в массиве, порожденные logspace(0, k, n), - это числа 10 ^ik/(n-1) для 0 ≤ я < п

>>> numpy.logspace(0, 2, 10)
array([   1.        ,    1.66810054,    2.7825594 ,    4.64158883,
          7.74263683,   12.91549665,   21.5443469 ,   35.93813664,
         59.94842503,  100.        ])
>>> [10 ** (i * 2 / 9.0) for i in xrange(10)]
[1.0, 1.6681005372000588, 2.7825594022071245, 4.641588833612778,
 7.742636826811269, 12.91549665014884, 21.544346900318832,
 35.938136638046274, 59.94842503189409, 100.0]

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

>>> ' '.join('{:.2f}'.format(10 ** (i * 2 / 19.0)) for i in xrange(20))
'1.00 1.27 1.62 2.07 2.64 3.36 4.28 5.46 6.95 8.86 11.29 14.38 18.33 23.36
 29.76 37.93 48.33 61.58 78.48 100.00'
>>> [int(0.5 + 10 ** (i * 2 / 19.0)) for i in xrange(20)]
[1, 1, 2, 2, 3, 3, 4, 5, 7, 9, 11, 14, 18, 23, 30, 38, 48, 62, 78, 100]

Интервал между значениями равен s (i) = 10 ^iK - 10 ^{(i-1) K} где K = k/(n - 1). Пусть m - наименьшее значение, такое, что s ( m) ≥ 1. (m = 7 в приведенном выше примере). Тогда, когда дубликаты удалены, существует ровно ⌊½ + 10 ^{(m -1) K} ⌋ + n - m оставшихся чисел.

Немного алгебр находит:

m = ⌈ - log (1 - 10 ^-K)/K log 10 ⌉

Проверьте, что.

from math import ceil, floor, log

def logspace_size(k, n):
    """
    Return the number of distinct integers we'll get if we round
    `numpy.logspace(0, k, n)` to the nearest integers and remove
    duplicates.

    >>> logspace_size(4, 100)
    84
    >>> logspace_size(4, 121)
    100
    >>> from numpy import around, logspace
    >>> all(logspace_size(k, n) == len(set(around(logspace(0, k, n))))
    ...     for k in xrange(1,10) for n in xrange(2,100))
    True
    """
    K = float(k) / (n - 1)
    m = int(ceil(- log(1 - 10 ** -K) / (K * log(10))))
    if m < n:
        return int(0.5 + 10 ** ((m - 1) * K)) + n - m
    else:
        return int(0.5 + 10 ** ((n - 1) * K))

Учения проходят, так что это выглядит хорошо для меня. Итак, все, что вам нужно сделать, это найти n, чтобы logspace_size(4, n) == 100. Вы можете сделать это с помощью бинарной отбивной или одного из методов scipy.optimize:

>>> f = lambda x, k, n:(logspace_size(k, x) - n)**2
>>> int(round(scipy.optimize.fmin(f, 100, args=(4,100), xtol=0.5, ftol=0.5)[0]))
Optimization terminated successfully.
         Current function value: 0.015625
         Iterations: 8
         Function evaluations: 17
122

Ответ 3

У меня есть при поиске простого метода для получения логарифмически разнесенных рядов (с базой 10) в python (без использования numpy). Но ваши решения являются сложными для моих сверхпростых требований.

def logarithmic_decade(numbers_per_decade, offset=10):
    for n in xrange(numbers_per_decade):
        yield offset * 10.0 ** (n / float(numbers_per_decade))

Так как это генератор для получения списка, вы должны:

numbers = list(logarithmic_decade(5))
print numbers
[10.0, 15.848931924611136, 25.118864315095802, 39.81071705534972, 63.095734448019336]

for p, n in zip(numbers, numbers[1:] + [100]):
    print 'prev = {p:.2f}, next = {n:.2f}, next/prev = {rt:.4f}'.format(p=p, n=n, rt=n / p)

Дает следующий результат:

prev = 10.00, next = 15.85, next/prev = 1.5849
prev = 15.85, next = 25.12, next/prev = 1.5849
prev = 25.12, next = 39.81, next/prev = 1.5849
prev = 39.81, next = 63.10, next/prev = 1.5849
prev = 63.10, next = 100.00, next/prev = 1.5849