Difference between revisions of "Fractions/fi"

From Free Pascal wiki
Jump to navigationJump to search
Line 89: Line 89:
 
** Palauttaa lukujen a ja b [[Greatest common divisor/fi|suurimman yhteisen tekijän]].
 
** Palauttaa lukujen a ja b [[Greatest common divisor/fi|suurimman yhteisen tekijän]].
 
* function Floor(D: Double): Int64; overload;
 
* function Floor(D: Double): Int64; overload;
** returns the integer part of D (subtracted with 1, if (D < 0))
+
** Palauttaa luvun D kokonaisosan (vähentää lukua yhdellä jos luku on pienempi kuin nolla). Niin sanottu lattiafunktio.
  
 
== Muunnos rutiinit ==
 
== Muunnos rutiinit ==
  
*function FloatToFraction(Value, Precision: Double): TFraction;
+
* 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)
+
** Palauttaa Value:n likiarvon  murtolukuna, esim. FloatTofraction(0.5,0.01) palauttaa 1/2 (puolikkaan)
**Precision defines the acceptable value for which (Abs(Result) - Abs(Value) <= Precision.
+
** 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 is bound to Value by a magnitude of 15 at most
+
** Precision määrittämiä suurusluokkia on 15.
**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.
+
** 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;
+
* function TryFloatToFraction(Value, Precision: Double; out F: TFraction; AcceptPrecisionError: Boolean): Boolean;
**return value depends on AcceptPrecisionError value:
+
** Palautettava murtoluku F riippuu annetusta AcceptPrecisionError arvosta:
***if (AcceptPrecisionError = True) then the function retruns True if an approxiamtion can be found
+
*** Jos AcceptPrecisionError on True niin funktio palauttaa True:n jos likiarvo löydettiin
***if (AcceptPrecisionError = False) the functions returns True if an approximation can be found AND Abs(Abs(Result)-Abs(Value)) <= Precision
+
*** Jos AcceptPrecisionError on False niin funktio palauttaa True:n jos likiarvo löydettiin ja Abs(Abs(Result)-Abs(Value)) <= Precision
**the value of F only makes sense if the function returns True
+
** Palautettava murtoluku F on hyväsyttävissä ainoastaan silloin kun funktion palauttaa True:n
*function FloatToFractionDef(Value, Precision: Double; Def: TFraction; AcceptPrecisionError: Boolean): TFraction;
+
* 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
+
** Palauttaa Value:n likiarvon  murtolukuna jos TryFloatToFraction(Value, Precision, F, AcceptPrecisionError: Boolean) onnistui, muuten palauttaa Def:n
*function StrToFraction(const S: String): TFraction;
+
* function StrToFraction(const S: String): TFraction;
**returns fraction that is represented in S, raises an EConvertError upon failure
+
** Palauttaa murtoluvun joka on merkkijonossa S, nostaa EConvertError poikkeuksen jos muunnos ei onnistu.
*function TryStrToFraction(const S: String; out F: TFraction): Boolean;
+
* function TryStrToFraction(const S: String; out F: TFraction): Boolean;
**retruns True if S can be converted to a fraction, otherwise returns False
+
** Palauttaa True:n jos merkkijono S voidaan muuntaa murtoluvuksi F, muuten palauttaa False:n.
**the value of F only makes sense f the function returns True
+
** Palautettava murtoluku F on hyväsyttävissä ainoastaan silloin kun funktion palauttaa True:n.
*function StrToFractionDef(const S: String; Def: TFraction): TFraction;
+
* function StrToFractionDef(const S: String; Def: TFraction): TFraction;
**returns the fraction represented in S if conversion succeeds, otherwise returns Def
+
** Palauttaa merkkijonon  murtolukuna jos muunnos onnistuu, muuten palauttaa Def:n.
  
 
== Esimerkkiohjelma ==
 
== Esimerkkiohjelma ==

Revision as of 10:36, 3 December 2015

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]