SDL

[Shaos]

У него он вообще трехмерный.

Я и говорю - два умножения
Трижды

[cr0acker]

Массив у мну такой:

Code: Select all

colorbuffer: array [0..leng,0..640,0..480] of color;

где

Code: Select all

type
color = record
  red,green,blue:uint8;

А пепеременные у мну

Code: Select all

 r,coeff1,coeff2,coeff3,coeff4,coeff5,coeff6,qx,qy,fi: extended; 
 

[cr0acker]

PS Если работать напрямую с фреймбуфером видеокарты в VESA режиме, то объединение буфера более чем логично. Не знаю за оконную систему Х-ов.

Имхо спорный вопрос, так низзя про многоплатформенность.

[cr0acker]

1) fi*j посчитать один раз, а не 4

До 18,43, после 17,70.

не считать Coeff2*Sin(Coeff3*fi*i) внутри цикла по j - оно всё равно меняться не будет, если i не меняется

17.56

[HardWareMan]

1) fi*j посчитать один раз, а не 4

До 18,43, после 17,70.

не считать Coeff2*Sin(Coeff3*fi*i) внутри цикла по j - оно всё равно меняться не будет, если i не меняется

17.56

Чото я не догоняю. fi у тебя вроде не меняется, так почему fi*i у тебя постоянно разные? Их кстати можно 2 раза вынести за цикл

Code: Select all

     for i:=0 to pred(480) do begin
      ext:=fi*i;   
      for j:=0 to pred(640) do begin
        qx := r *(Sin(ext*j/Coeff1)-Coeff2*Sin(Coeff3*ext));
        qy := r *(Sin(ext*j/Coeff4)-Coeff5*Sin(Coeff6*fi*j));
        ColorBuffer[x,j,i].Red:=trunc(Abs(qy)) Mod 256;
        ColorBuffer[x,j,i].Green:=trunc(Abs(qy+qx)) Mod 256;
        ColorBuffer[x,j,i].Blue:=trunc(Abs(qx)) Mod 256;
        end;
     end; 

Тип ext'а нужный задай.

[cr0acker]

Тип ext'а нужный задай.

17,4

Code: Select all

for i:=0 to pred(480) do begin
       uno:=coeff2*Sin(Coeff3*fi*i);
       fii:=fi*i;
      for j:=0 to pred(640) do begin
        fiji:=fii*j;
        qx := r *(Sin(fiji/Coeff1)-uno);
        qy := r *(Sin(fiji/Coeff4)-Coeff5*Sin(Coeff6*fi*j));
        ColorBuffer[x,j,i].Red:=trunc(Abs(qy)) Mod 256;
        ColorBuffer[x,j,i].Green:=trunc(Abs(qy+qx)) Mod 256;
        ColorBuffer[x,j,i].Blue:=trunc(Abs(qx)) Mod 256;
        end;
     end;

[cr0acker]

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

[Shaos]

Тип ext'а нужный задай.

17,4

Code: Select all

for i:=0 to pred(480) do begin
       uno:=coeff2*Sin(Coeff3*fi*i);
       fii:=fi*i;
      for j:=0 to pred(640) do begin
        fiji:=fii*j;
        qx := r *(Sin(fiji/Coeff1)-uno);
        qy := r *(Sin(fiji/Coeff4)-Coeff5*Sin(Coeff6*fi*j));
        ColorBuffer[x,j,i].Red:=trunc(Abs(qy)) Mod 256;
        ColorBuffer[x,j,i].Green:=trunc(Abs(qy+qx)) Mod 256;
        ColorBuffer[x,j,i].Blue:=trunc(Abs(qx)) Mod 256;
        end;
     end;

17.4 - это ты в чём меряешь и что?

Ещё можно Coeff6*fi посчитать снаружи циклов и ColorBuffer[x,j,i] брать один раз как указтель и Red,Green,Blue присваивать по указателю - будет чуть быстрее

[Shaos]

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

Можешь для начала плавающий табличный синус попробовать

[cr0acker]

Тип ext'а нужный задай.

17,4

Code: Select all

for i:=0 to pred(480) do begin
       uno:=coeff2*Sin(Coeff3*fi*i);
       fii:=fi*i;
      for j:=0 to pred(640) do begin
        fiji:=fii*j;
        qx := r *(Sin(fiji/Coeff1)-uno);
        qy := r *(Sin(fiji/Coeff4)-Coeff5*Sin(Coeff6*fi*j));
        ColorBuffer[x,j,i].Red:=trunc(Abs(qy)) Mod 256;
        ColorBuffer[x,j,i].Green:=trunc(Abs(qy+qx)) Mod 256;
        ColorBuffer[x,j,i].Blue:=trunc(Abs(qx)) Mod 256;
        end;
     end;

17.4 - это ты в чём меряешь и что?

В секундах, это время работы ста циклов по X.

[cr0acker]

Нашел такую старинную либу, адаптировал для ФПЦ:

Code: Select all

UNIT FastTrig;

(*******************************************************************
  Modified for FreePascal by cr0acker^NedoPC team, cr0acker(at)mail.ru

  Turbo-Pascal Unit for super fast trigonometric functions.
  (c) copyright 1990,91 by Klaus Hartnegg,  www.klaus-hartnegg.de
   Free for non-commercial use.

  SuperFastSin determines function value by lookup in tables (arrays)
  that get initialized on the first call to the function or by a
  explicit call to the initialization procedure.

  Accuracy is a function of memory that you allow to be used
  for the table.

  FastSin is 5 times faster than Turbo's sin.
  SuperFastSin is even 9.5 times faster but less accurate.
  (times measured with FTRIGDEM on a 25 MHz 80386)

  SuperFastSin simply looks up the nearest value in a table.
  FastSin uses taylor series of first order around 0.

x***********************************************************************)


INTERFACE

type
  FPtr_1r_1r = function (x:real) : real;

var
  FastSin, SuperFastSin : FPtr_1r_1r;

{ the variable FastSin behaves like
Function FastSin          (x : real) : real; }

Function FastCos          (x : real) : real;
Function SuperFastCos     (x : real) : real;
Function FastTan          (x : real) : real;
Function FastCot          (x : real) : real;

Procedure Init;
{ this initialization will be called automatically upon the first
  use of one of the functions but can be called explicitely to prevent
  unexpected delay in the middle of your program. }


IMPLEMENTATION


const
  Resolution = 256;
  pi         = 3.1415926535897932385;
  Step       = pi / resolution;


var
  Sinus       : array[0..Resolution] of real;
  EndOfTaylor : integer;



const
  initialized : boolean = false;



Function FastSin1 (x : real) : real;
var i  : integer;
    s  : real;
    negativ : boolean;
begin
  negativ := (x < 0);
  s := abs (x * (Resolution / pi));
  i := trunc (s);
  if odd(i div Resolution) then negativ := not negativ;
  i := i mod Resolution;

  if ((i <= EndOfTaylor) or (i >= Resolution - EndOfTaylor))
{  and (abs (frac(s) - 0.5) > 0.25) } then begin
     x := abs (pi * frac (x / pi));
     if x > pi/2 then x := abs(pi - x);
     if negativ then FastSin1 := -X else FastSin1 := X;
  end
  else if negativ then FastSin1 := - Sinus[i]
  else Fastsin1 := Sinus[i];
end;



Function SuperFastSin1 (x : real) : real;
var i  : integer;
    s  : real;
    negativ : boolean;
begin
  i := trunc (x * ( Resolution / pi) );
  negativ := false;
  if i < 0 then begin
     negativ := true;
     i := -i;
  end;
  i := i mod (2 * Resolution);

  if i > Resolution then begin
     negativ := not negativ;
     i := i - Resolution;
  end;
  if negativ then SuperFastSin1 := - Sinus[i]
  else SuperFastSin1 := Sinus[i];
end;



Function FastCos (x:real) : real;
begin
  Fastcos := Fastsin (x + pi/2);
end;


Function SuperFastCos (x:real) : real;
begin
  SuperFastcos := SuperFastsin (x + pi/2);
end;


Function FastTan (x:real) : real;
begin
  FastTan := FastSin(x) / FastCos(x);
end;


Function FastCot (x:real) : real;
begin
  FastCot := FastCos(x) / FastSin(x);
end;



Procedure Init;
var x : real;
    i : integer;
begin
  if FastSin = @FastSin1 then exit; { is already installed }

  x := Step / 2;
  for i := 0 to Resolution do begin
     Sinus[i] := sin (x);
     x := x + Step;
  end;

  EndOfTaylor := 0;
  x := Step / 2;
  while abs( x - sin(x)) < Step / 2 do begin
     inc (EndOfTaylor);
     x := x + Step;
  end;
  dec (EndOfTaylor,2);

  FastSin := @FastSin1;
  SuperFastSin := @SuperFastSin1;
end;



Function FastSin_Init (x:real) : real;
begin
  Init;
  FastSin_Init := FastSin(x);
end;


Function SuperFastSin_Init (x:real) : real;
begin
  Init;
  SuperFastSin_Init := SuperFastSin(x);
end;



BEGIN
  FastSin := @FastSin_Init;
  SuperFastSin := @SuperFastSin_init;
END.

Он почти в два раза медленнее чем стандартные функции. Похоже придется отказаться от мультиплатофрменности и сделать FPCшные байндинги для http://gruntthepeon.free.fr/ssemath/

[HardWareMan]

Нашел такую старинную либу, адаптировал для ФПЦ:

Он почти в два раза медленнее чем стандартные функции. Похоже придется отказаться от мультиплатофрменности и сделать FPCшные байндинги для http://gruntthepeon.free.fr/ssemath/

Да ты посмотри на SuperFastSin1 и FastSin1, тут работы по оптимизации непочатый край. И это называется суперфаст. Я понимаю, что во времена внешнего FPU это было быстрее, чем занос чисел в стек, вычисление и забор результата, но сейчас FPU внутри проца, соответственно время тратится только на вычисление. Дерзай, из этого модуля можно кое-что выжать.