десятичный логарифм элементарными действиями

По таблице + разложение в ряд Тейлора

Формула для логарифма есть на википедии https://ru.wikipedia.org/wiki/Ряд_Тейлора . Он работает от 0 до 1; но, если тебе нужен логарифм 1000, то берешь -ln(1/1000), и получаешь профит. Ряд сходится медленно, но для тестов покатит.

lg x = ln x / ln 10

Может даже через вычисление логарифмов по другим основаниям...

Я не знаю верилог, но lg(x) = ln(x)/ln(10).

log10(x) = ln(x)/ln(10)
ln(x) находится разложением в ряд Тейлора.

Еще лучше использовать не ln(1+x), а следующее:
ln((1+x)/(1-x)) = ln(1+x) - ln(1-x)
Дело в том, что ln(1+x) плохо сходится при x=1 (и близких значениях). Однако в предложенном варианте ln(2) находится при x=1/3.

http://melpon.org/wandbox/permlink/ZIzQgnd9Q3wyy9eM самое банальное. Умножение на 10 делается через сдвиги и сложение http://goo.gl/K8Fs6u

Если надо быстро, то таблицей поиска можно. Например если десятичный логарифм по основанию 10 от числа в диапазоне от 0 до 9999 то делаем сравнение через https://gcc.gnu.org/onlinedocs/gcc/Case-Ranges.html
от 0 до 9 - 0;
от 10 до 99 - 1;
итд

Ряд Маклорена для натурального логарифма..., для x от -1 до 1, но тоже сойдет, как-то можно будет преобразовать.

Была мысль и таким образом сделать: http://www.asic-world.com/verilog/pli.html

Забавно читать решения с использованием вещественной арифметики для Verilog, когда не указано вообще, с какой точностью надо этот логарифм считать и можно(рационально) ли для этого использовать плавучку. Если нужен десятичный логарифм чтоб со знаками после запятой, можно описанный тут способ http://everything2.com/title/Logarithm algorithm попробовать

Готовые функции не предлагать, просто в Verilog нет готовых функций на эту тему, но есть конечно готовые громоздкие IP-core. Мне же надо это не для синтеза схемы, а просто для тестбенча, где доступен императивный подход.

Особой точности не надо, хотя бы пару знаков после запятой.

Особой точности не надо, хотя бы пару знаков после запятой.

Таблицы Брадиса «хватит всем» :)

Ну тут все достаточно просто, надо только знать свойства логарифма. Например если надо найти с точностью до 2 знаков логарифм
log10 (123456) можно сделать следующие шаги:
log10 (123456) (используя код http://melpon.org/wandbox/permlink/ZIzQgnd9Q3wyy9eM ) = 5 (с точностью до целых, нет дробной части) 10 ^ 5 = 100000
Сделам log10 который определен на интервале от 1 до 9.9999999999... через таблицу поиска (типа https://gcc.gnu.org/onlinedocs/gcc/Case-Ranges.html ) c промежутками, которых достаточно для получения нужной точности log10 (123456/100000) = 0.0915122...
http://www.wolframalpha.com/input/?i=log10 (123456/100000)
Примерное решение (с двумя знаками): 5 + 0.09 = 5.09
http://www.wolframalpha.com/input/?i=log10 (123456) и действительно, так и есть

Да, я уже реализовал и вижу - при x близким к 1 вообще ужасный результат. Но я не понял, как из этого ln((1+x)/(1-x)) = ln(1+x) - ln(1-x) высчитать тупо ln(x)???

log10(x) = ln(x)/ln(10) я уже сделал и это работает точно.

Но я не понял, как из этого ln((1+x)/(1-x)) = ln(1+x) - ln(1-x) >>высчитать тупо ln(x)???

Если нужно вычислить ln a, то, очевидно, (1+x)/(1-x) = a. Откуда x = (a-1)/(a+1).

Спасибо, Евгений Перельман :) Эх, совсем я заржавел за 8 лет после универа...

Ln я на VHDL реализовывал по вот этой статейке. Сложение+сдвиг+табличка.

Этот код дает неверный результат:

  int fxlog(int x) {
  int t,y;

  y=0xa65af;
  if(x<0x00008000) x<<=16,              y-=0xb1721;
  if(x<0x00800000) x<<= 8,              y-=0x58b91;
  if(x<0x08000000) x<<= 4,              y-=0x2c5c8;
  if(x<0x20000000) x<<= 2,              y-=0x162e4;
  if(x<0x40000000) x<<= 1,              y-=0x0b172;
  t=x+(x>>1); if((t&0x80000000)==0) x=t,y-=0x067cd;
  t=x+(x>>2); if((t&0x80000000)==0) x=t,y-=0x03920;
  t=x+(x>>3); if((t&0x80000000)==0) x=t,y-=0x01e27;
  t=x+(x>>4); if((t&0x80000000)==0) x=t,y-=0x00f85;
  t=x+(x>>5); if((t&0x80000000)==0) x=t,y-=0x007e1;
  t=x+(x>>6); if((t&0x80000000)==0) x=t,y-=0x003f8;
  t=x+(x>>7); if((t&0x80000000)==0) x=t,y-=0x001fe;
  x=0x80000000-x;
  y-=x>>15;
  return y;
  }

Но я не понял, как из этого ln((1+x)/(1-x)) = ln(1+x) - ln(1-x) высчитать тупо ln(x)???

(1+t)/(1-t)=x => t=(x-1)/(x+1)
ln(x)=ln(1+t) - ln(1-t)
Учти еще, что хотя разложение ln(1+t)=t-(t^2)/2+(t^3)/3+... содержит все возможные степени t, при вычислении разности
ln(1+t) - ln(1-t)=2(t + (t^3)/3 + ...)
четные степени уходят. Кстати, здесь ответ, почему данный ряд сходится лучше исходного: из знакопеременного мы перешли к ряду знакопостоянному.

учел это?

the result of the function are both expressed as fixed-point values with 16 fractional bits

Вот что получилось, алгоритм неверно считает, мне нужно считать логарифмы чисел порядка от 100 до 500000:

#include <QCoreApplication>
#include <QDebug>

qreal my_ln(qreal x);
qreal my_lnb(qreal x);
qreal my_log(qreal x);
int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);
	qDebug("ln= %.10f", my_ln((qreal)1.5)); // OK
	qDebug("log= %.10f", my_log((qreal)1.5)); // OK
	qDebug("lnb= %.10f", my_lnb((qreal)1.5)); // OK
	qDebug("lnb(1450)v1= %.10f", -my_lnb((qreal)1/1450)); // failed, must be 7.279318835
	qDebug("lnb(1450)v2= %.10f", my_lnb((qreal)1450)); // failed, must be 7.279318835
	return 0;
}

qreal my_log(qreal x)
{
	return (qreal) my_ln(x) / 2.302585093;
}

qreal my_lnb(qreal x)
{
	qreal t = (qreal) (1 - x) / (1 + x);
	qreal r = -(my_ln(1 + t) - my_ln(1 - t));
	return r;
}

qreal my_ln(qreal x)
{
	qreal r = (x - 1);
	bool sign = false;
	for(int i = 2; i < 20; i++)
	{
		qreal px = (x - 1);
		for(int j = 0; j < (i - 1); j++) px *= (x - 1);
		if(sign) r += (qreal) px / i;
		else r -= (qreal) px / i;
		sign = !sign;
	}
	return r;
}

ln= 0.4054651404
log= 0.1760912731
lnb= 0.4054651081
lnb(1450)v1= 4.2391139414
lnb(1450)v2= 4.2391139414

Последние два должны быть 7.279318835

Учел, но даже если поделить на 2^16 получится странный результат. Причем пока я не добавил unsigned то получался вообще результат со знаком минус:

unsigned int fxlog(int x)
{
	unsigned int t = 0, y = 0;
	y=0xa65af;
	if(x<0x00008000) x<<=16,              y-=0xb1721;
	if(x<0x00800000) x<<= 8,              y-=0x58b91;
	if(x<0x08000000) x<<= 4,              y-=0x2c5c8;
	if(x<0x20000000) x<<= 2,              y-=0x162e4;
	if(x<0x40000000) x<<= 1,              y-=0x0b172;
	t=x+(x>>1); if((t&0x80000000)==0) x=t,y-=0x067cd;
	t=x+(x>>2); if((t&0x80000000)==0) x=t,y-=0x03920;
	t=x+(x>>3); if((t&0x80000000)==0) x=t,y-=0x01e27;
	t=x+(x>>4); if((t&0x80000000)==0) x=t,y-=0x00f85;
	t=x+(x>>5); if((t&0x80000000)==0) x=t,y-=0x007e1;
	t=x+(x>>6); if((t&0x80000000)==0) x=t,y-=0x003f8;
	t=x+(x>>7); if((t&0x80000000)==0) x=t,y-=0x001fe;
	x=0x80000000-x;
	y-=x>>15;
	return y;
}

qreal new_ln(qreal x)
{
	unsigned int li = fxlog(x);
	qDebug() << "for" << x << "li=" << li;
	return 0;
}

for 1450 li= 4294717537

Сунул в исходник с расширением *.c и стал корректный результат!!! Годный точный до третьего-четвертого знака после запятой результат! Спасибо! Правда максимальное входное число это 32767, но я уже дальше свойствами логарифмов добью до нужного диапазона...

Спасибо всем за проявленное сострадание :)

Радиус сходимости и погрешность уже оценили? :-)

Да, сойдет, большая точность и не требуется.

Оценка погрешности: http://paste.org.ru/?3lbnst

Там нет округления, так что ошибка не на 0.5 а на 1.0, но и так сойдет, еще раз спасибо!

Большие числа нужно преобразовывать к маленьким. В частности 1450 = 1000*1,45 Тогда lg 1450 = 3+lg 1,45

Да не за что. Мне только вот что интересно - как ты его будешь к симулятору прикручивать? Есть возможность мешать Verilog и C в тестбенче или просто в лоб переписать на Verilog?

Есть возможность мешать Verilog и C в тестбенче или просто в лоб переписать на Verilog?

Я уже переписал на Verilog для тестбенча, всё работает как часики. А уже отдельная функция домножает на коэффициент чтобы логарифм стал десятичным и умноженным на 20.

Завтра чуть причешу и выложу исходник, да там всё на 99% идентично версии на языке Си.

Есть конечно PLI и да, можно тупо совать модули на Си в код на Verilog но лишь для моделей в симуляторах, я это делал но наверное лет 8 назад, уже забыл как, а сейчас мне проще на Verilog вкатить.

Читабельнее чем на VHDL) Хотя это, наверное, не синтезируется нормально.

Это вообще никак не будет синтезироваться, но такую вот функцию не сложно допилить до синтезируемости, правда работать будет тактов 10-15, но всё же будет легковеснее типичных IPкоров для этой же цели.

(1+t)/(1-t)=x => t=(x-1)/(x+1)

Объясни, Распиши это преобразование, вроде вижу, что все ясно как арбуз, а парсер ломается, аж стыдно :-D

Спасибо