Fractions/fi

From Free Pascal wiki
Revision as of 14:48, 1 December 2015 by Djzepi (talk | contribs)
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;
  • 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;
    • returns the integer part of D (subtracted with 1, if (D < 0))

Muunnos rutiinit

  • function FloatToFraction(Value, Precision: Double): TFraction;
    • returns an approximation of Value in the form of a fraction, e.g. FloatTofraction(0.5,0.01) returns 1/2 (one half)
    • Precision defines the acceptable value for which (Abs(Result) - Abs(Value) <= Precision.
    • Precision is bound to Value by a magnitude of 15 at most
    • FloatToFraction in fact is a function varable which is initialized to the MF_FloatTofraction() function. You can assign your own function to it if wanted.
  • function TryFloatToFraction(Value, Precision: Double; out F: TFraction; AcceptPrecisionError: Boolean): Boolean;
    • return value depends on AcceptPrecisionError value:
      • if (AcceptPrecisionError = True) then the function retruns True if an approxiamtion can be found
      • if (AcceptPrecisionError = False) the functions returns True if an approximation can be found AND Abs(Abs(Result)-Abs(Value)) <= Precision
    • the value of F only makes sense if the function returns True
  • function FloatToFractionDef(Value, Precision: Double; Def: TFraction; AcceptPrecisionError: Boolean): TFraction;
    • returns the found approximation (F) if TryFloatToFraction(Value, Precision, F, AcceptPrecisionError: Boolean) succeeds, otherwise returns Def
  • function StrToFraction(const S: String): TFraction;
    • returns fraction that is represented in S, raises an EConvertError upon failure
  • function TryStrToFraction(const S: String; out F: TFraction): Boolean;
    • retruns True if S can be converted to a fraction, otherwise returns False
    • the value of F only makes sense f the function returns True
  • function StrToFractionDef(const S: String; Def: TFraction): TFraction;
    • returns the fraction represented in S if conversion succeeds, otherwise returns Def

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]