Fractions/fi

From Free Pascal wiki

English (en) suomi (fi)

Mikä on Fractions unit?

Fractions on käännösyksikko (unit) joka suorittaa laskuja murtoluvuilla.
Käännösyksikkö syntyi keskustelun pohjalta discussion on the Lazarus forum.

Subversion

Löydät Fractions unitin

svn https://lazarus-ccr.svn.sourceforge.net/svnroot/lazarus-ccr/components/fractions

Tai voit vain katsella sitä viewcv:n avulla

http://sourceforge.net/p/lazarus-ccr/svn/HEAD/tree/components/fractions/

Ominaisuudet

TFraction tyyppi

TFraction on niin sanottu "advanced record": eli tietue laajennettuna metodeilla ja ominaisuuksilla (Property) .

TFraction ominaisuudet

  • property Numerator: Int64;
    • Asettaa ja hakee murtoluvun osoittajan (jaettavan).
  • property Denominator: Int64;
    • Asettaa ja hakee murtoluvun nimittäjän (jakajan).
    • Jos jakajaa yritetään laittaa nollaksi (0) niin nostaa EZeroDivide poikkeuksen.

TFraction metodit

  • procedure Normalize;
  • function ToString: String;
    • Palauttaa merkkijonoesityksen murtoluvusta (supistusta ei tehdä), esim. kun osoittaja on 10 ja nimittäjä on 5 niin funktio palauttaa '10/5'.
  • function Resolve: String;
    • Palauttaa merkkijonoesityksen murtoluvusta supistamisen jälkeen , esim. kun osoittaja on 4 ja nimittäjä on 3 niin funktio palauttaa '1 1/3'.
  • function ToFloat: Double;
    • Palauttaa liukuluku esityksen murtoluvusta, esim kun Numerator (osoittaja) = 1 ja Denominator (nimittäjä) = 3 niin funktio palauttaa 0.3333333333333


Murtolukujen tekeminen

  • function Fraction(ANumerator, ADenominator: Int64): TFraction;
    • Luo murtoluvun osoittaja/nimittäjä, esim. Fraction(1,2) tekee murtoluvun 1/2 (puoli).
  • function Fraction(AIntPart, ANumerator, ADenominator: Int64): TFraction;
    • Luo murtoluvun, esim. Fraction(1,1,2) antaa murtoluvun 1 1/2 (yksi ja puoli).


Tuetut laskut

Operaattorit (Overloaded operators)

  • = (yhtäsuuri)
  • < (pienempi kuin)
  • > (suurempi kuin)
  • <= (pienempi tai yhtäsuuri kuin)
  • >= (suurempi tai yhtäsuuri kuin)
  •  := (saa arvokseen): Tämä sallii kokonaisluvun ( Int64 ) tai merkkijonon arvon antamisen muuttujalle
  • + (lisää)
  • - (vähennä)
  • * (kertominen): overloaded for fractions and Int64
  • / (jakolasku): overloaded for fractions and Int64
  • ** (potenssiin korotus): only allowed for Integers (on right hand side)

Matemaattiset funktiot

  • function Min(a, b: TFraction): TFraction; inline; overload;
    • Palauttaa a:n jos a <= b muuten palauttaa b:n.
  • function Max(a, b: TFraction): TFraction; inline; overload;
    • palauttaa a:n jos a >= b muuten palauttaa b:n.
  • function InRange(const AValue, AMin, AMax: TFraction): Boolean; inline; overload;
    • Palauttaa true:n jos AValue >= AMin ja AValue <= AMax muuten palauttaa false:n
  • function EnsureRange(const AValue, AMin, AMax: TFraction): TFraction; inline; overload;
    • Palauttaa AMin:n jos AValue < AMin muuten palauttaa AMax vain jos AValue > AMax muussa tapauksessa palauttaa AValue:n
  • function Sign(const AValue: TFraction): TValueSign; inline; overload;
    • Palauttaa NegativeValue:n jos AValue < 0 muuten palauttaa PositiveValue:n jos AValue > 0 muussa tapauksessa palauttaa AZeroValue:n
  • function IsZero(const AValue: TFraction): Boolean; overload;
    • Palauttaa true:n jos AValue on nolla (0) muuten palauttaa false:n.
  • function Abs(const AValue: TFraction): TFraction; overload;
    • Palauttaa AValue jos AValue >= 0 muuten palauttaa -1*AValue.


Yleiskäyttöiset funktiot

  • function GreatestCommonDivisor(a, b: Int64): Int64;
  • function Floor(D: Double): Int64; overload;
    • Palauttaa luvun D kokonaisosan (vähentää lukua yhdellä jos luku on pienempi kuin nolla). Niin sanottu lattiafunktio.

Muunnos rutiinit

  • function FloatToFraction(Value, Precision: Double): TFraction;
    • Palauttaa Value:n likiarvon murtolukuna, esim. FloatTofraction(0.5,0.01) palauttaa 1/2 (puolikkaan)
    • Precision määrittää murtoluvun hyväksyttävän arvon. Hyväksyttävänä arvona pidetään arvoa joka on Abs(Result) - Abs(Value) <= Precision.
    • Precision määrittämiä suurusluokkia on 15.
    • FloatToFraction on tosiasiassa funktiomuuttuja joka on alustettu MF_FloatTofraction() funktiolla. Voit liittää sen tilalle jonkun muun funktion jos haluat.
  • function TryFloatToFraction(Value, Precision: Double; out F: TFraction; AcceptPrecisionError: Boolean): Boolean;
    • Palautettava murtoluku F riippuu annetusta AcceptPrecisionError arvosta:
      • Jos AcceptPrecisionError on True niin funktio palauttaa True:n jos likiarvo löydettiin
      • Jos AcceptPrecisionError on False niin funktio palauttaa True:n jos likiarvo löydettiin ja Abs(Abs(Result)-Abs(Value)) <= Precision
    • Palautettava murtoluku F on hyväsyttävissä ainoastaan silloin kun funktion palauttaa True:n
  • function FloatToFractionDef(Value, Precision: Double; Def: TFraction; AcceptPrecisionError: Boolean): TFraction;
    • Palauttaa Value:n likiarvon murtolukuna jos TryFloatToFraction(Value, Precision, F, AcceptPrecisionError: Boolean) onnistui, muuten palauttaa Def:n
  • function StrToFraction(const S: String): TFraction;
    • Palauttaa murtoluvun joka on merkkijonossa S, nostaa EConvertError poikkeuksen jos muunnos ei onnistu.
  • function TryStrToFraction(const S: String; out F: TFraction): Boolean;
    • Palauttaa True:n jos merkkijono S voidaan muuntaa murtoluvuksi F, muuten palauttaa False:n.
    • Palautettava murtoluku F on hyväsyttävissä ainoastaan silloin kun funktion palauttaa True:n.
  • function StrToFractionDef(const S: String; Def: TFraction): TFraction;
    • Palauttaa merkkijonon murtolukuna jos muunnos onnistuu, muuten palauttaa Def:n.

Esimerkkiohjelma

program example;

{$mode objfpc}{$H+}
{$apptype console}

uses
  Classes, sysutils, fractions, math;

var
  F1, F2: TFraction;
  D, Prec: Double;
  i: Integer;
begin
  F1 := Fraction(1,1,3); // 1 1/3
  F2 := Fraction(4,3);   // 4/3
  writeln('F1.ToString = ',F1.ToString); // '4/3'
  writeln('F1.Resolve  = ',F1.Resolve);  // '1 1/3'
  writeln('F1.ToFloat  = ',F1.ToFloat:16:16); // 1.3333333333333333
  writeln('F2.ToString = ',F2.ToString); // '4/3'
  writeln('(F1 = F2)   = ',F1=F2);         //True

  F1 := Fraction(1,2);
  F2 := Fraction(1,3);
  writeln(F1.ToString,' * ',F2.ToString,'   = ',(F1*F2).Resolve);  // '1/6'
  writeln(F1.ToString,' / ',F2.ToString,'   = ',(F1/F2).Resolve);  // '1 1/2'
  writeln(F1.ToString,' + ',F2.ToString,'   = ',(F1+F2).Resolve);  // '5/6'
  writeln(F1.ToString,' - ',F2.ToString,'   = ',(F1-F2).Resolve);  // '1/6'
  writeln(F1.ToString,' ** 2    = ',(F1**2).Resolve);  // '1/6'

  D := 0.25;
  F1 := FloatToFraction(D, 0.000001);
  writeln('FloatTofraction(0.25) -> ',F1.ToString);   // '1/4'
  writeln;
  writeln('Approximations of Pi:');
  writeln('                                              [Pi = ',Pi:16:16,']');
  Prec := 1.0;
  for i := 1 to 10 do
  begin
    Prec := Prec / 10;
    F2 := FloatTofraction(Pi, Prec);
    writeln('FloatTofraction(Pi,',Prec:10:10,') = ',Format('%-13s',[F2.Resolve]),'   [',F2.ToFloat:16:16,']');
  end;
end.

Ohjelma tulostaa:

F1.ToString = 4/3
F1.Resolve  = 1 1/3
F1.ToFloat  = 1.3333333333333333
F2.ToString = 4/3
(F1 = F2)   = TRUE
1/2 * 1/3   = 1/6
1/2 / 1/3   = 1 1/2
1/2 + 1/3   = 5/6
1/2 - 1/3   = 1/6
1/2 ** 2    = 1/4
FloatTofraction(0.25) -> 1/4

Approximations of Pi:
                                              [Pi = 3.1415926535897932]
FloatTofraction(Pi,0.1000000000) = 3 1/7           [3.1428571428571428]
FloatTofraction(Pi,0.0100000000) = 3 1/7           [3.1428571428571428]
FloatTofraction(Pi,0.0010000000) = 3 16/113        [3.1415929203539825]
FloatTofraction(Pi,0.0001000000) = 3 16/113        [3.1415929203539825]
FloatTofraction(Pi,0.0000100000) = 3 16/113        [3.1415929203539825]
FloatTofraction(Pi,0.0000010000) = 3 16/113        [3.1415929203539825]
FloatTofraction(Pi,0.0000001000) = 3 4703/33215    [3.1415926539214212]
FloatTofraction(Pi,0.0000000100) = 3 4703/33215    [3.1415926539214212]
FloatTofraction(Pi,0.0000000010) = 3 4703/33215    [3.1415926539214212]
FloatTofraction(Pi,0.0000000001) = 3 14093/99532   [3.1415926536189365]