Denne artikkelen gir kildekoden for en fin, ren gjennomføring av en klasse å kompilere den diskrete, kumulative fordelingsfunksjon for et utvalg datasett. CDF danner grunnlaget for grunnleggende deskriptiv statistikk. (Denne artikkelen opprinnelig dukket opp i The Unofficial Nyhetsbrev fra DelphiUsers) TDistribution ClassThis artikkelen gir kildekoden for en fin, ren gjennomføring av en klasse å kompilere den diskrete, kumulative fordelingsfunksjon for et utvalg data sett. CDF danner grunnlaget for grunnleggende beskrivende statistics.TDistribution vil automatisk legge "binger" for å CDF som dataelementene er samlet, eller du kan forhåndsdefinere bin grensene før analysere et datasett. Dette auto-utvidelse av CDF binger fungerer best med sorterte datasett (men for kule sorteringskomponenter se http://www.connix.com/~btober/sorting.htm). I de fleste tilfeller vil det fungere rimelig godt uten pre-sortering data.The klasse stammer fra TStringList, slik at du kan bruke Strings eiendom for å definere en tekststreng som beskriver hver 'bin', f.eks String [0]: = 'Jan'; String [1]: = 'februar'; . . . String [11]: = 'desember'; Dermed klassen fleksibelt støtter implementeringen innenfor en rekke brukergrensesnitt (merk at dette ikke er en brukergrensesnitt komponent Anmeldelser - det er "bare" en klasse som gir en spesifikke, statistisk funksjonalitet ... det er opp til deg å implementere brukergrensesnittet passer for ditt bruksområde) sikret klassen gir egenskaper for å estimere prøven data totalt og mener (basert på ED) .En eksempel prosjektet er også inkludert. < i> {*********************************************** *******************}
{klasse for utvikling av diskrete, kumulativ fordelingsfunksjon}
{Copyright © 2000, Berend M. Tober. Alle rettigheter reservert. }
{Forfatterens E-post - mailto: [email protected]}
{Andre komponenter på}
{http://www.connix.com/~ btober /delphi.htm}
{************************************* *****************************}
enhet
Cdf; {Den kumulative fordelingsfunksjon (CDF) for kontinuerlig, real tilfeldig variabel X er definert som en funksjon F (x) der F (x) = P (X < = x), dvs. sannsynligheten for at X < = x. Den diskrete tilfellet er tilsvarende definert. Den TDistribution klassen brukes til å generere en empirisk CDF for et gitt datasett ved å telle antallet av verdier fra prøvedatasettet som faller inn i en av et sett av diskrete "binger". På denne måten kan du raskt få et kvantitativt bilde av et datasett. Klassen stammer fra TStringList, slik at du kan bruke Strings eiendom for å definere en tekststreng som beskriver hver 'bin', f.eks String [0]: = 'Jan'; String [1]: = 'februar'; . . . String [11]: = 'desember';}
grensesnitt
bruker
klasser; skriv
TDistributionItem = class product: (TObject) < b> privat
FBin: Double; {Øvre grense på bin}
FCount: LongInt; offentlig
konstruktør
Lag (Verdi: Double, Count: LongInt); -funksjonen
Accumulate (verdi: Double): LongInt; eiendom
Bin: Double Les
FBin; eiendom
Count: LongInt Les
FCount; slutten
; TDistribution = class product: (TStringList) privat
-funksjonen
GetMean: dobbel; -funksjonen
GetTotal: Double; offentlig
konstruktør
Lag; destructor
Destroy; styre
; prosedyre
Clear; -funksjonen
Accumulate (verdi: Double): LongInt; -funksjonen
AddObject ( konst
S: string
; AObject: TObject): Integer; overstyring
; prosedyre
FreeObjects; prosedyre
Sett (indeks: Integer; konst
Verdi: TDistributionItem); -funksjonen
FreeObject (Indeks: Integer): Integer; -funksjonen
Get (Indeks: Integer): TDistributionItem; eiendom
Mean: Double Les
GetMean; eiendom
objekter [indeks: Integer]: TDistributionItem Les
Få skrive
Put; eiendom
Totalt: Double Les
GetTotal; slutten
; gjennomføringen
konstruktør
TDistributionItem.Create (Verdi: Double, Count: LongInt); begynne
arvet
Lag; FBin: = verdi; FCount: = Count; slutten
; -funksjonen
TDistributionItem.Accumulate (verdi: Double): LongInt; begynner
Resultat: = - 1; hvis
Value < = FBin da
{Økning telling av bin når Value < = x}
begynne
inc (FCount); Resultat: = FCount; slutten
; slutten
; konstruktør
TDistribution.Create; begynne
arvet
Lag; slutten
; destructor
TDistribution.Destroy; begynne
Clear; arvet
Destroy; slutten
; -funksjonen
TDistribution.AddObject ( konst
S: string
; AObject: TObject): Integer; {Legg en "bin" til CDF, i riktig rekkefølge}
Var
i: Integer; begynne
{Finn hvor du skal sette inn nye " bin '. Dette er like før den minste 'bin' som overstiger størrelsen på nye 'bin'. }
Resultat: = Count; hvis
Count > 0 da
for
jeg: = pred (Count) nedfor
0
i hvis
TDistributionItem (AObject) Bin < objekter [i] Bin da
Resultat: = i; hvis
Resultat < 0 da
Resultat: = arvet
AddObject (S, AObject) {Hvis ingen slike "bin", tilføyer ny}
annet
InsertObject (Resultat, S, AObject) {Insert ny bin før neste største}
slutten
; -funksjonen
TDistribution.Accumulate (Verdi : Double): LongInt; {Regn dette dataverdi i CDF}
Var
i: LongInt; begynne
hvis
Count = 0 < b> da
AddObject ( '', TDistributionItem.Create (verdi, 0)) {må ha minst en 'bin'}
annet
hvis
verdi >. objekter [pred (Count)] bin da
{Hvis verdien overstiger største "bin", og deretter legge ny en som er stor nok}
AddObject ( '', TDistributionItem.Create (verdi, Objects [pred (Count)] Count.)); for
i: = 0 for bedriften pred (Count)
i Resultat: = Objekter [i] .Accumulate (Verdi); slutten
; -funksjonen
TDistribution.Get (Indeks: Integer): TDistributionItem; begynner
Resultat: = TDistributionItem ( arvet
objekter [Indeks]); slutten
; -funksjonen
TDistribution.FreeObject (Indeks: Integer): Integer; begynner
Resultat: = - 1; hvis
Index > = Count da
Exit; hvis
Objekter [Indeks] < > nil
da
begynne
Objekter [Indeks] .Gratis; Objekter [Indeks]: = nil
; slutten
; Slett (Index); hvis
Index > = Count da
Resultat: = pred (Count) annet
hvis
Count = 0 da
Resultat : = - en annet
Resultat: = Indeks; slutten
; prosedyre
TDistribution.FreeObjects; Var
i: Integer; begynne
hvis
Count > 0 da
for
i: = pred (Count) nedfor
0 ikke
FreeObject (i); slutten
; prosedyre
TDistribution.Put (indeks: Integer; konst
Verdi: TDistributionItem); begynne
arvet
objekter [Indeks]: = Verdi; < b> slutten
; prosedyre
TDistribution.Clear; begynne
FreeObjects; arvet
Clear; slutten
; -funksjonen
TDistribution.GetTotal: Double; {Dette er et estimat av selve prøven total}
Var
jeg: integer; begynner
Resultat: = 0; hvis
Count = 0 da
Exit; Resultat: = Objekter [0] Bin * Objekter [0] .Count; for
i: = 1 for bedriften pred (Count)
i Resultat: = Resultat + (objekter [i] Bin * (objekter [i] .Count-objekter [pred (i)] Count).); {*** Dette er en alternativ måte å beregne total *** Resultat: = Objekter [0] Bin * Objekter [0] .Count; for i: = 1 til pred (Count) gjør Resultat: = Resultat + (. Objekter [i] BIN + Objekter [Pred (i)] Bin) * (Objects [i] .Count - Objekter [pred (i)] .Telle); Resultat: = Resultat /2.0; }
slutten
; -funksjonen
TDistribution.GetMean: double; {Dette er et estimat av selve prøven mener}
begynne
Resultat : = 0,0; hvis
Count > 0 da
. Resultat:. = GetTotal /objekter [pred (Count)] Count; slutten
; slutten
Eksempel implementering
program
Eksempel; bruker
WinCRT, cdf; konst
Data1: Array product: [1..10] av
Fast = (66,73,73,81,81,81,81,85,85,89); {Merk: Dette datasettet er forhåndssortert. TDistribution vil fortsatt jobbe med usorterte data, men du kan ikke få en god cdf mindre du forhåndsdefinere CDF binger. Dette gjelder spesielt hvis det første elementet i datasettet skjer for å være den største (prøve det ved å re-arrangere de ovennevnte datasettet!) Fordi automatisk tillegg av binger vil legge en eneste bin der alle data vil bli regnet. }
Var
i, j: Word; begynne
med
TDistribution.Create
i begynne
for
i: = 1 for bedriften 10
i Accumulate (Data1 [i]); writeln ( 'Mean =', Mean: 6: 4); writeln ( 'Total =', Total: 6: 4); {Print ut kvantitativ oppsummering}
for
i: = 0 for bedriften pred (Count) gjøre
writeln(Objects[i].Bin:6:2,#44,Objects[i].Count,#44,Objects[i].Count/Objects[pred(Count)].Count:6:3); {Print ut rå 'histogram'}
for
i: = 0 for bedriften pred (Count)
i begynne
for
j: = 1 for bedriften AVKORT (. 40 * objekter [i] .Count /objekter [pred (Count)] Count) ikke
skrive ( '*'); writeln; slutten
; Gratis; slutten
;. slutten