Fractions/fi
From Lazarus wiki
Jump to navigationJump to search
│
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;
- Supistaa murtoluvut jakamalla osoittajan ja nimittäjän suurimmalla yhteisellä tekijällä, esim. murtoluvusta 10/5 tulee 2/1.
- 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;
- Palauttaa lukujen a ja b suurimman yhteisen tekijän.
- 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
- Palautettava murtoluku F riippuu annetusta AcceptPrecisionError arvosta:
- 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]