Я пока не представляю как возвести число в степень 0.1, для меня это как представить 5-мерное пространство. В интернете объясняют только через дроби

Чем тебя не устраивает объяснение через дроби? Оно же простое и понятное.

Алгоритм для вычисления корня n-ной степени?

Я пока не представляю как возвести число в степень 0.1

Это суть радикал 10й степени. Про то как вычислять арифметическими действиями выше написал

Про то как вычислять арифметическими действиями выше написал

Выше это где? Как вычислить корень степени n?

Например тут в примере тупо подогнали число чтобы его можно было просто вычислить и вытащить корень - читеры!

Как вычислить корень степени n?

https://ru.wikipedia.org/wiki/Алгоритм_нахождения_корня_n-ной_степени

А с наименьшим количеством арифметических дейстий будет наверное разложение в ряд (1 + x) ^ a

Вот например тут описан метод Ньютона и другие. Судя по всему мне это не подходит.

Имеет ли имя это разложение в ряд для нахождения корня, чтобы я загуглил его?

Не страдай фигнёй, в IEEE 754 практически тривиально считаются log2 и exp2, любое возведение в степень выражается через них.

Этот ряд довольно медленно сходится, на практике его никто не считает.

Причем здесь вообще метод Ньютона? Ссылка же на обобщенный алгоритм для степени n

Имеет ли имя это разложение в ряд для нахождения корня, чтобы я загуглил его?

Разложение в ряд не для нахожденя корня, а для решения твоего вопроса самым быстрым путем. Ряды Тейлора смотри

Я догадываюсь, но ТС вряд ли спрашивает для того чтобы это реализовывать. Ему просто интересно, наверное, ну или не знаю

Это называется показательная функция. Она же экспонента. Ряд для экспоненты - в гугле. Аппроксимации там же.

x^{0,1} = e^{0,1*ln(x)}

Как найти логарифм тебе уже писали.

e^{t} так же находишь через ряд тейлора

ТС вряд ли спрашивает для того чтобы это реализовывать. Ему просто интересно, наверное, ну или не знаю

абсолютно не интересно ;) и да, спрашиваю чтобы реализовать сначала на C++, затем перенести на Verilog

zhekas Точно! Можно же через это: Экспоненциальная функция может быть определена различными эквивалентными способами. Например, через ряд Тейлора. Как-то я забыл про то что экспоненту вычислить можно через ряд, слабоват я в математике... Вроде и ограничения по диапазону нету.

Тогда то, что я говорил про корни это точно не нужно. А выше кто-то говорит что ряд тоже медленный. Надо узнать его про быстрый способ, а вообще, почему бы не посмотреть как это в glibc например

Тебе нужно что-то типа такого.

почему бы не посмотреть как это в glibc например

Там ясно как - тупо FPU. Кстати, уже к теме не относится, но какой алгоритм работы FPU у x86 или у ARM? Как-то туго гуглится, но мне это интересно. Знаю только про https://ru.wikipedia.org/wiki/CORDIC но в FPU может что-то другое.

Чето не очень считает, более менее точно от 0.0 до 3.0:

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

double my_exp(double x);
int fact(int n);

// e^3.456 = 31,689962805

int main()
{
	printf("my_exp(3.456)= %.5f\n", my_exp(3.456));

	bool failed = false;
	for(int i = 0; i < 5000; i++)
	{
		double x = (double) (rand() % 300) / 100;
		double my_e = my_exp(x);
		double et_e = exp(x);
		double err = fabs(et_e - my_e);
		printf("%.3f: %5.3f -> %5.3f @ %.3f", x, my_e, et_e, err);
		if(err > 0.1)
		{
			printf("					!!!\n");
			failed = true;
		}
		else printf("\n");
	}

	if(failed) printf("\nFAILED\n");
	else printf("\nOK\n");

	return 0;
}

double my_exp(double x)
{
	double res = 1 + x;
	for(int i = 2; i < 10; i++)
	{
		double nx = x;
		for(int j = 1; j < i; j++) nx *= x;
		res += (double) nx / fact(i);
	}
	return res;
}

int fact(int n)
{
	if(n < 0) return 0;
	if(!n) return 1;
	return n * fact(n - 1);
}

Решение задачи:

10^x = e^(x*ln10)

double delog20(double x)
{
	return my_exp((double) x * M_LN10 / 20);
}

Вплоть до 35 дБ мне точности хватает!

Проблема решена :)

Точность ряда тейлора определяется следующим членом последовательности.

Тоесть чтобы точность была скажем a=1/1000, необходмо, чтобы x^{n+1}/(n+1)! < a, тогда ряд до x^n/n! будет обладать необходимой точностью.

См. код вычисления экспоненты http://www.netlib.org/fdlibm/e_exp.c Как видишь, все очень просто.

1) Сначала приводим аргумент x к отрезку [0,ln(2)/2=0.34658], вычитая из x целое k ln(2). Теперь функция выглядит как exp(ln(2)*k+r) = exp(ln(2)*k) * exp(r) = 2^k * exp(r)

2) потом аппроксимируем полиномом exp(r) на этом отрезке, а результат домножаем на 2^k. Вот и все.

А вот вместо ряда Тейлора лучше получить минимаксный полином. https://ru.wikipedia.org/wiki/Алгоритм_Ремеза, функция MiniMaxApproximation в Mathematica.

Посчитать квадратный корень, корень из корня etc. Взять двоичное представление степени и умножить нужные.

И чем он будет лучше полинома, полученного по МНК в данном случае?

Там ясно как - тупо FPU.

FPU есть далеко не везде.

res += (double) nx / fact(i);

Только в продакшн такое не пихай. Вот так правильнее:

double my_exp(double x) {
        double res = 1 + x;
        double nx  = x;
        int    n   = 1;
        for (int i = 2; i < 14; ++i) {
                nx  *= x;
                n   *= i;
                res += nx / n;
        };
        return res;
};

При итерировании дальше 14 int переполняется.

несколько ответов

1) 10^(x)=8^(2^(-N)*[2^(N)*log8(10)*x]), выделяешь целую часть выражения в квадратных скобках и возводишь в нее число 8^(2^(-N)) или 8^(2^(N)), а потом 1.0 делишь на результат.

2) Выбираешь шаг точности A(близким, но не равным 1.0, можно рациональное число) 10^(x)=A^(logA(10)*x), опять берешь целую часть и возводишь в эту степень.

3) Составляешь таблицу и ищешь в ней делением пополам. Ответ подставляешь в разложение экспоненциальной функции... если 10^(F-h)<10^x<=10^F, то 10^x=e^([F*ln(10)]-{[ln(10)](F-x)}), в квадратных - константы,в фигурных - новая неизвестная, экспоненту которой можно интерполировать рядами... и первую экспоненту делишь на вторую.

Нужен ли матан и диплом программисту?

Можно и МНК, но речь выше шла о Тейлоре, которого обычно использовать не нужно.

Как-то идея с рядом Тейлора мне не по душе. Ну, разложишь [latex](1+x)^a[/latex] по степеням x, а там проблема, что число в дробной степени плохо считается при приближении числа к нулю. В данном примере, при [latex]x=-1[/latex]. Как следствие — малый радиус сходимости ряда Тейлора (в данном примере — единица).

Не знаю исходные условия, но если есть функция sqrt, то лучше свести задачу к возведению числа в квадрат и вычислению sqrt. С большой точностью дробную степень можно представить как ряд из степеней двойки (включающий также и отрицательные степени). Переход от степеней к числу элементарен: сумму заменяем на умножение, увеличение в два раза — возведение в квадрат, уменьшение в два раза — вычисление корня (sqrt).

Это, конечно, так. Просто получать «на лету» равномерные приближения сильно затратнее чем среднеквадратичные.

В данном случае на лету ничего вычислять не нужно, функция заранее известна и не меняется. Можно хоть неделю потратить на поиск наилучшего полинома.

Никаких продакшенов, суть сишного кода просто алгоритм отработать. Твой вариант обязательно попробую :)

НУЖЕН 1000%

Попробовал твой вариант и стало потрясающе точно! В чем же секрет, в чем была ошибка моего кода? Конкретно в «res += (double) nx / fact(i);»?

Вот решение :)

my_exp(0.1)= 1.105
my_exp(0.5)= 1.649
my_exp(1.0)= 2.718
my_exp(2.0)= 7.389
my_exp(3.0)= 20.085
my_exp(3.5)= 33.113

delog20(0.1)= 1.012
delog20(0.5)= 1.059
delog20(5.0)= 1.778
delog20(10.0)= 3.162
delog20(25.0)= 17.783
delog20(30.0)= 31.621

function real my_exp(real x);
real res, nx;
int n;
begin
	res = 1 + x;
	nx = x;
	n = 1;
	for(int i = 2; i < 13; ++i) begin
		nx = nx * x;
		n = n * i;
		res += nx / (n * 1.0);
		//$display("x= %.3f, i= %0d, n= %0d, nx= %.3f, res= %.5f", x, i, n, nx, res);
	end
	return res;
end
endfunction

function real delog20(real x);
real res, d20;
begin
	d20 = (x * 2.30258509299404568402) / 20.0;
	res = my_exp(d20);
	return res;
end
endfunction

Использовал как раз Тейлора, видно что точность только в районе до 3.0, зато e^(x+y+z) = (e^x)*(e^y)*(e^z), а стало быть exp(x) = exp(x/4)*exp(x/4)*exp(x/4)*exp(x/4) - можно точно посчитать когда x=12.