Гамма-функция и факториал: вычислительные вопросы

Вообще, я нашёл, что гамма-функция вычисляется точно так же формулой Стирлинга с той лишь разницей, что одни коэффицент не умножается, а делится.

Pia, гамма-функция действительно является обобщением факториала (говоря простым языком, "одно и то же"), и это действительно можно доказать. Попробуйте всё же почитать книги по матанализу.

Это только для целых чисел. Ну сколько раз можно повторять?!
Г(-0.5+1)<>-0.5! что легко проверить.

Ну и что толку? Формула нахождения гамма-функции ни чуть не точнее, и как перевести результат гамма-функции в факториал мы не знаем.

Факториал определен только для целых неотрицательных! Как он может вне области своего определения давать значения?

Вообще-то, да, Г(n+1)=n! и для нецелых - я проверил своей программой. Спасибо, Vladimirovich.
И что толку? Вы игнорирует тот факт, что у нас нет формулы вычисления гамма-функции. Та, что у меня есть, не более точна. Это по-сути одна и та же.

Факториалы нецелых чисел нужны, например, для статистического описания нейросетевых преобразователей биометрия/код ключа доступа биномиальным законом распределения зависмимых биометрических данных, и много где ещё.

Это вы игнорируете то, что вам пишут. Я вам три разных формулы приводил, всё не в прок.

Как он определяется?

Все три - модификация формулы Стирлинга, которую я и использую. Если бы мне знать больше чисел ряда Стирлига, алгоритм был бы точнее.

Вычисляется - похоже, что только нажатием кнопок на калькуляторе Windows. Для очень больших - формулой Стирлинга, которую я использую с алгоритме программы.

Wiki пишет

The factorial function can also be defined for non-integer values, but this requires more advanced tools from mathematical analysis. The function that "fills in" the values of the factorial between the integers is called the Gamma function, denoted Γ(z) for integers z no less than 1, defined by... http://en.wikipedia.org/wiki/Factorial

Kак я понимаю это, что для х! (х real) нужно пользаватся определением Гамма функ.

В том-то и дело, что модификации. Там у рядов другие коэффициенты совсем, один расходящийся, другой сходящийся, параметр есть, можно точность выбрать. Тонкостей достаточно.

Ещё раз внимательней посмотрел. Вот это кажется убедительным!!!

Pia, а вы попробуйте вашу программу... продать! Думаю, это прорыв - не иначе, и желающих найдётся пруд пруди.

Да, и получить Нобелевскую премию по математике. Жаль, что такой нет.

Это Вы откуда скопипастили? Вы сами можете объяснить вышенаписанное?

Какая разница?

Ну так я для расчёта факториалов использовал модифицированну формулу гамма-функции.
Какие у кого проблемы?

Неправда. У меня есть (был) справочник по математике для учащихся ВУЗов, там даётся формула Стирлинга с описанием, как сейчас помню, "Факториалы больших чисел могут быть выражены приближённо формулой Стирлинга. Эта формула имеет место и не при целом n".

Всё понятно. "Волны перекатывались через мол и падали вниз стремительным домкратом" ©

Последняя формула даёт результат даже для небольших нецелых чисел z. Так факториал можно вычислить даже для отрицательных величин. Но совсем не быстро и всего до 8 значимых знаков.
————————————————
{$N+}

const
d=1000000; { Уменьшить для большей частоты вывода на экран состояния }
l=100000000; { Увеличить для большей точности вычисления }

var
C,z,r1,r2:extended;
n,d1:longint;

begin
C:=-0.57721566490153286060651209008240243104215933593992;
repeat
readln(z);
z:=z+1;
r1:=1/(1+z/1)*exp(z/1);
d1:=d;
for n:=2 to l do
begin
r1:=r1*(1/(1+z/n))*exp(z/n);
if n=d1 then
begin
write(#13,d1/l*100:0:1,'%');
d1:=d1+d;
end;
end;
r2:=exp(C*z)/z*r1;
writeln(#13,r2);
until false;
end.
————————————————-

Первая ничуть не лучше. После 15 минут счёта дала 9 знаков. За приемливое время можно получить 5-6. Как за это время калькулятор Windows даёт 32 знака если не использует формулу с длинным рядом чисел Стирлинга?
——————————-
{$N+}

const
d=100000; { Уменьшить для большей частоты вывода на экран состояния }
l=1000000; { Увеличить для большей точности вычисления }

var
z,r1,r2:extended;
n,d1:longint;

begin
repeat
readln(z);
z:=z+1;
r1:=exp(ln(1+1/1)*z)/(1+z/1);
d1:=d;
for n:=2 to l do
begin
r1:=r1*exp(ln(1+1/n)*z)/(1+z/n);
if n=d1 then
begin
write(#13,d1/l*100:0:1,'%');
d1:=d1+d;
end;
end;
r2:=1/z*r1;
writeln(#13,r2);
until false;
end.
————————

М-да...
Наметилась утечка мозгов с ветки "Университет" на "Кухню".

Цикл был не миллион, а 2 миллиарда. А что, быстрее находить логарифм второй части, чем возводить в степень первую?

Ага. На пальцах считать.
Вообще, хватит кривляться. Ответ на первый мой вопрос: нет, нельзя.

нет, exp(ln(1+1/1)*z)/(1+z/1) = exp(ln(2)*z-ln(1+z)) = exp(ln(2)*z)/(1+z)
1/1 и z/1 я написал для наглядности, что n=1.

Обновил программу в первом посте

Чего-то не понял. Не мудрствуя лукаво, за 30 мин пишется нечто вроде этого:

Код:

program Factorial;
{$APPTYPE CONSOLE}
uses
  SysUtils;

function Sum(const A, B: string): string;
var
  LenA, LenB: Integer;
  IdxA, IdxB: Integer;
  Next, DigitSum: Integer;
  I: Integer;
begin
  LenA := Length(A);
  LenB := Length(B);

  if LenA < LenB then
  begin
    Result := Sum(B, A);
    Exit;
  end;

  SetLength(Result, LenA);
  Next := 0;

  for I := 0 to LenA-1 do
  begin
    IdxA := LenA - I;
    IdxB := LenB - I;
    DigitSum := Byte(A[IdxA]) - Byte('0') + Next;
    if IdxB >= 1 then
      DigitSum := DigitSum + Byte(B[IdxB]) - Byte('0');

    Byte(Result[IdxA]) := (DigitSum mod 10) + Byte('0');
    Next := DigitSum div 10;
  end;

  if Next <> 0 then
    Result := Char(Next + Byte('0')) + Result;
end;

function Prod(const A: string; B: Char; Shift: Integer): string; overload;
var
  LenA: Integer;
  DigitA, DigitB, DigitProd: Integer;
  Next: Integer;
  I: Integer;
begin
  LenA := Length(A);
  DigitB := Byte(B) - Byte('0');

  SetLength(Result, LenA + Shift);

  for I := 0 to Shift-1 do
    Result[LenA + Shift - I] := '0';

  Next := 0;

  for I := LenA downto 1 do
  begin
    DigitA := Byte(A[i]) - Byte('0');
    DigitProd := DigitA * DigitB + Next;
    Byte(Result[i]) := (DigitProd mod 10) + Byte('0');
    Next := DigitProd div 10;
  end;

  if Next <> 0 then
    Result := Char(Next + Byte('0')) + Result;
end;

function Prod(const A, B: string): string; overload;
var
  LenA, LenB: Integer;
  I, Shift: Integer;
begin
  LenA := Length(A);
  LenB := Length(B);

  if LenA < LenB then
  begin
    Result := Sum(B, A);
    Exit;
  end;

  if LenB < 1 then
  begin
    Result := '';
    Exit;
  end;

  Result := Prod(A, B[LenB], 0);
  Shift := 1;

  for I := LenB-1 downto 1 do
  begin
    Result := Sum(Result, Prod(A, B[i], Shift));
    Shift := Shift + 1;
  end;
end;

function Fact(Value: Integer): string;
var
  I: Integer;
begin
  Result := '1';
  for I := 2 to Value do
    Result := Prod(Result, IntToStr(I));
end;

var
  A: Integer;

begin
  repeat
    Write('A = '); ReadLn(A);
    if A < 0 then Break;
    WriteLn(Fact(A));
    WriteLn;
    if A = 0 then Break;
  until False;
end.

Ну-ну. Поробуйте этой программой найти (16!)! или 16.5! или -0.5!

Факториал это функция, определенная только на множестве целых положительных чисел. Существует 2^2^алеф-нуль функций, которые принимают в целых положительных точках значения, равные факториалу. Вам какую?

Чтобы найти 16!! нужен просто комп пошустрее. Но как ты по другому получишь точное значение факториала?

А так задача сформулирована некорректно: надо задать точность, количество операций. А так изучай второй том Кнута, выбирай более точное представление действительных чисел, бери да реализуй формулу Стирлинга, ...