function Extended2Str(E: Extended): KOLString;
const
  DS: Char = '.';
  PP = 3;
  //15+8 = Extended
  //15+7 = Double
  Precision = {$ifdef FPC64}22{$else}23{$endif};
  DefPE = 18; //= 19 in 64bit for Precision=23

var
  Exponent, Q{, PP}, PE, DstL: Integer; 
  S: string;
  Dst: PChar;

begin
  Str(E:Precision, S); // '-2.00000000000000E+0001'

  //PP := Pos('.', S);
  if {PP = 0} S[PP] <> '.' then { NAN or other special case }
  begin
    Result := Trim(S); { Delete spaces }
    // Result := '0';
    Exit;
  end;


  { Consider removing exponent }
  //PE := Pos('E', Result);
  //if PE = 0 then Exit; // Something wrong?
  PE := DefPE;

  { Read exponent }
  Exponent := 0;
  Dst := @S[PE + 2]; // E+'0001' ; E+'001' in 64bit prec=23
  while Dst^ <> #0 do
  begin
    Exponent := Exponent*10 + Ord(Dst^)-Ord('0');
    Inc(Dst);
  end;
  if S[PE+1] = '-' then
    Exponent := -Exponent;

  { Trim trailing zeros}   
  Dst := @S[PE - 1];
  while (Dst^ = '0') do // Stop at non-zero or '.'
  begin
    Dec(PE);
    Dec(Dst);
  end;

  if (PE = PP + 1) and (S[2] = '0') then // ' 0.00000000000000E+0000'
  begin
    Result := '0';
    Exit;
  end;


  if Exponent >= 0 then
  begin
    { Shift point to right }

    DstL := Exponent + 1; // Digits before dst '.'

    if S[1] = '-' then Inc(DstL); // '-' symbol

    Q := PE - PP - 1; // Digits between src '.' and 'E'
    if Q > Exponent then
    begin
      Inc(DstL); // Need '.' symbol in output
      Inc(DstL, Q - Exponent); // Digits after dst '.'
    end;

    { Compose output string }
    SetLength(Result, DstL);
    Dst := Pointer(Result);

    // '-' symbol
    if S[1] = '-' then
    begin
      Dst^ := '-';
      Inc(Dst);
    end;

    Dst^ := S[2]; Inc(Dst); // 1 digit before src '.'

    // Digits from S[3] to dst '.'
    Q := PP + 1; // After src '.' 
    while (Q < PE) and (Exponent > 0) do
    begin
      Dst^ := S[Q];
      Inc(Dst);
      Inc(Q);
      Dec(Exponent);
    end;

    if Q < PE then
    begin
      Dst^ := DS; // Dst '.'
      Inc(Dst);
      // Digits after dst '.'
      while Q < PE do
      begin
        Dst^ := S[Q]; 
        Inc(Dst);
        Inc(Q);
      end;
    end
    else // Extra '0'-s at the dst end
    begin
      while Exponent > 0 do
      begin
        Dst^ := '0';
        Inc(Dst);
        Dec(Exponent);
      end;
    end;
    
  end
  else
  begin
    {Shift point to left}    
    DstL := PE - PP - 1; // Digits between src '.' and 'E'
    if S[1] = '-' then Inc(DstL); // '-' symbol
    Inc(DstL); // '0' before '.'
    Inc(DstL); // '.' symbol in output

    Exponent := -Exponent; // Abs(Exponent)
    Inc(DstL, Exponent); // Extra zeros at left 

    { Compose output string }
    SetLength(Result, DstL);
    Dst := Pointer(Result);

    // '-' symbol
    if S[1] = '-' then
    begin
      Dst^ := '-';
      Inc(Dst);
    end;

    Dst^ := '0'; Inc(Dst); // First '0'
    Dst^ := DS; Inc(Dst); // '.'

    for Q := 2 to Exponent do // Remained extra zeros at left 
    begin
      Dst^ := '0';
      Inc(Dst);
    end;

    Dst^ := S[2]; Inc(Dst); // 1 digit before src '.'
    // Digits between src '.' and 'E'
    for Q := PP + 1 to PE - 1 do
    begin
      Dst^ := S[Q]; 
      Inc(Dst);
    end;
  end;

end;

  Precision = {$ifdef FPC64}21{$else}23{$endif};
  DefPE = {$ifdef FPC64}17{$else}18{$endif};

function Extended2Str( E: Extended ): KOLString;
    function UnpackFromBuf( const Buf: array of Byte; N: Integer ): KOLString;
    var I, J, K, L: Integer;
    begin
      SetLength( Result, 16 );
      J := 1;
      for I := 7 downto 0 do
      begin
        K := Buf[ I ] shr 4;
        Result[ J ] := KOLChar( Ord('0') + K );
        Inc( J );
        K := Buf[ I ] and $F;
        Result[ J ] := KOLChar( Ord('0') + K );
        Inc( J );
      end;
      //Assert( Result[ 1 ] = '0', 'error!' );
      Delete( Result, 1, 1 );
      if  N <= 0 then
      begin
          while N < 0 do
          begin
              Result := '0' + Result;
              Inc( N );
          end;
          Result := '0.' + Result;
      end else
      if  N < Length( Result ) then
      begin
          Result := Copy( Result, 1, N ) + '.' + CopyEnd( Result, N + 1 );
      end else
      begin
          while N > Length( Result ) do
          begin
            Result := Result + '0';
          end;
          Exit; {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>}
      end;
      L := Length( Result );
      while L > 1 do
      begin
        if  (Result[ L ] <> '0')
        and (Result[ L ] <> '.') then
            break;
        Dec( L );
        if Result[ L + 1 ] = '.' then break;
      end;
      if L < Length( Result ) then Delete( Result, L + 1, MaxInt );
    end;
var
  S: Boolean;
var F: Extended;
    N: Integer;
    Buf1: array[ 0..9 ] of Byte;
    I10: Integer;
  {$IFDEF PAS_ONLY}
  procedure Ext2BDC(E: Extended; Buf1: array of byte);
  {$IFDEF WIN64} var F: Extended; {$ENDIF}
  asm
    {$IFDEF WIN64}
    MOVQ   qword ptr F, E
    FLD    F
    {$ELSE}
    FLD    E
    {$ENDIF}
    FBSTP  [Buf1]
  end;
  {$ENDIF}
begin
  Result := '0';
  if E = 0 then Exit; {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>}
  S := E < 0;
  if S then E := -E;

  N := 15;
  F := 5E12;
  I10 := 10;
  while E < F do
  begin
    Dec( N );
    E := E * I10;
  end;
  if N = 15 then
  while E >= 1E13 do
  begin
    Inc( N );
    E := E / I10;
  end;

  while TRUE do
  begin
    {$IFDEF PAS_ONLY}
    Ext2BDC(E, Buf1);
//    if TRUNC(Abs(E)) >= 10000000 then
//       break;
    {$ELSE}
    asm
      FLD    [E]
      FBSTP  [Buf1]
    end;
    {$ENDIF}
    if Buf1[ 7 ] <> 0 then break;
    E := E * I10;
    Dec( N );
  end;
  Result := UnpackFromBuf( Buf1, N );
  if S then Result := '-' + Result;
end;

function fann_create_standard(num_layers: Cardinal): PFann; cdecl; varargs;
function fann_create_sparse(connection_rate: single; num_layers: Cardinal): PFann; cdecl; varargs;       
function fann_create_shortcut(connection_rate: single): PFann; cdecl; varargs;