examples/CBuilder/ExRndU.cpp

// ***** BEGIN LICENSE BLOCK *****
// * Version: MPL 1.1
// *
// * The contents of this file are subject to the Mozilla Public License Version
// * 1.1 (the "License"); you may not use this file except in compliance with
// * the License. You may obtain a copy of the License at
// * http://www.mozilla.org/MPL/
// *
// * Software distributed under the License is distributed on an "AS IS" basis,
// * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
// * for the specific language governing rights and limitations under the
// * License.
// *
// * The Original Code is TurboPower SysTools
// *
// * The Initial Developer of the Original Code is
// * TurboPower Software
// *
// * Portions created by the Initial Developer are Copyright (C) 1996-2002
// * the Initial Developer. All Rights Reserved.
// *
// * Contributor(s):
// *
// * ***** END LICENSE BLOCK *****
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "ExRndU.h"
//---------------------------------------------------------------------------
#pragma link "strandom"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

const
  AnsiString DistNames[12] = {
    "Beta", "Cauchy", "ChiSquared", "Erlang", "Exponential",
    "F", "Gamma", "LogNormal", "Normal", "Student's t",
    "Uniform", "Weibull"};


//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
  int i;
  int UniformInx;

  cboDist->Items->Clear();
  UniformInx = -1;
  for (i = 0; i < 12; i++) {
    cboDist->Items->Add(DistNames[i]);
    if (DistNames[i].AnsiCompare("Uniform") == 0)
      UniformInx = i;
  }
  cboDist->ItemIndex = UniformInx;
  cboDistChange(this);
  PRNG = new TStRandomSystem(0);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
{
   delete PRNG;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::cboDistChange(TObject *Sender)
{
  switch (cboDist->ItemIndex) {
    case 0 : PrepForBeta(); break;
    case 1 : PrepForCauchy(); break;
    case 2 : PrepForChiSquared(); break;
    case 3 : PrepForErlang(); break;
    case 4 : PrepForExponential(); break;
    case 5 : PrepForF(); break;
    case 6 : PrepForGamma(); break;
    case 7 : PrepForLogNormal(); break;
    case 8 : PrepForNormal(); break;
    case 9 : PrepForT(); break;
    case 10: PrepForUniform(); break;
    case 11: PrepForWeibull(); break;
  }
  updRightClick(this, btNext);
  updLeftClick(this, btNext);
  edtParm1->Text = FloatToStr(Value1);
  edtParm2->Text = FloatToStr(Value2);

}
//---------------------------------------------------------------------------
void __fastcall TForm1::updRightClick(TObject *Sender, TUDBtnType Button)
{
  lblRight->Caption = IntToStr(updRight->Position);
  GraphRight = updRight->Position;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::updLeftClick(TObject *Sender, TUDBtnType Button)
{
  lblLeft->Caption = IntToStr(updLeft->Position);
  GraphLeft = updLeft->Position;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PrepForBeta()
{
  lblParm1->Caption = "Shape 1:";
  lblParm1->Visible = true;
  lblParm2->Caption = "Shape 2:";
  lblParm2->Visible = true;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = true;
  edtParm2->Enabled = true;
  updLeft->Position = 0;
  updRight->Position = 1;
  Value1 = 2.0;
  Value2 = 4.0;
  GetRandom = GetBeta;
}

void __fastcall TForm1::PrepForCauchy()
{
  lblParm1->Caption = "(none)";
  lblParm1->Visible = true;
  lblParm2->Visible = false;
  edtParm1->Visible = false;
  edtParm1->Enabled = false;
  edtParm2->Visible = false;
  edtParm2->Enabled = false;
  updLeft->Position = -5;
  updRight->Position = 5;
  Value1 = 0.0;
  Value2 = 0.0;
  GetRandom = GetCauchy;
}

void __fastcall TForm1::PrepForChiSquared()
{
  lblParm1->Caption = "Degrees of freedom:";
  lblParm1->Visible = true;
  lblParm2->Visible = false;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = false;
  edtParm2->Enabled = false;
  updLeft->Position = 0;
  updRight->Position = 20;
  Value1 = 5.0;
  Value2 = 0.0;
  GetRandom = GetChiSquared;
}

void __fastcall TForm1::PrepForErlang()
{
  lblParm1->Caption = "Mean:";
  lblParm1->Visible = true;
  lblParm2->Caption = "Order:";
  lblParm2->Visible = true;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = true;
  edtParm2->Enabled = true;
  updLeft->Position = 0;
  updRight->Position = 5;
  Value1 = 1.0;
  Value2 = 4.0;
  GetRandom = GetErlang;
}

void __fastcall TForm1::PrepForExponential()
{
  lblParm1->Caption = "Mean:";
  lblParm1->Visible = true;
  lblParm2->Visible = false;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = false;
  edtParm2->Enabled = false;
  updLeft->Position = 0;
  updRight->Position = 10;
  Value1 = 1.0;
  Value2 = 0.0;
  GetRandom = GetExponential;
}

void __fastcall TForm1::PrepForF()
{
  lblParm1->Caption = "Degrees of freedom 1:";
  lblParm1->Visible = true;
  lblParm2->Caption = "Degrees of freedom 2:";
  lblParm2->Visible = true;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = true;
  edtParm2->Enabled = true;
  updLeft->Position = 0;
  updRight->Position = 20;
  Value1 = 10.0;
  Value2 = 5.0;
  GetRandom = GetF;
}

void __fastcall TForm1::PrepForGamma()
{
  lblParm1->Caption = "Shape:";
  lblParm1->Visible = true;
  lblParm2->Caption = "Scale:";
  lblParm2->Visible = true;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = true;
  edtParm2->Enabled = true;
  updLeft->Position = 0;
  updRight->Position = 10;
  Value1 = 2.0;
  Value2 = 1.0;
  GetRandom = GetGamma;
}

void __fastcall TForm1::PrepForLogNormal()
{
  lblParm1->Caption = "Mean:";
  lblParm1->Visible = true;
  lblParm2->Caption = "Standard deviation:";
  lblParm2->Visible = true;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = true;
  edtParm2->Enabled = true;
  updLeft->Position = 0;
  updRight->Position = 10;
  Value1 = 0.0;
  Value2 = 1.0;
  GetRandom = GetLogNormal;
}

void __fastcall TForm1::PrepForNormal()
{
  lblParm1->Caption = "Mean:";
  lblParm1->Visible = true;
  lblParm2->Caption = "Standard deviation:";
  lblParm2->Visible = true;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = true;
  edtParm2->Enabled = true;
  updLeft->Position = -5;
  updRight->Position = 5;
  Value1 = 0.0;
  Value2 = 1.0;
  GetRandom = GetNormal;
}

void __fastcall TForm1::PrepForT()
{
  lblParm1->Caption = "Degrees of freedom:";
  lblParm1->Visible = true;
  lblParm2->Visible = false;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = false;
  edtParm2->Enabled = false;
  updLeft->Position = -10;
  updRight->Position = 10;
  Value1 = 10.0;
  Value2 = 0.0;
  GetRandom = GetT;
}

void __fastcall TForm1::PrepForUniform()
{
  lblParm1->Caption = "(none)";
  lblParm1->Visible = true;
  lblParm2->Visible = false;
  edtParm1->Visible = false;
  edtParm1->Enabled = false;
  edtParm2->Visible = false;
  edtParm2->Enabled = false;
  updLeft->Position = 0;
  updRight->Position = 1;
  Value1 = 0.0;
  Value2 = 0.0;
  GetRandom = GetUniform;
}

void __fastcall TForm1::PrepForWeibull()
{
  lblParm1->Caption = "Shape:";
  lblParm1->Visible = true;
  lblParm2->Caption = "Scale:";
  lblParm2->Visible = true;
  edtParm1->Visible = true;
  edtParm1->Enabled = true;
  edtParm2->Visible = true;
  edtParm2->Enabled = true;
  updLeft->Position = 0;
  updRight->Position = 10;
  Value1 = 2.0;
  Value2 = 3.0;
  GetRandom = GetWeibull;
}

double __fastcall TForm1::GetBeta()
{
  return PRNG->AsBeta(Value1, Value2);
}

double __fastcall TForm1::GetCauchy()
{
  return PRNG->AsCauchy();
}

double __fastcall TForm1::GetChiSquared()
{
  if (Value1 > 65535.0)
    throw(Exception(
      "TForm1.GetChiSquared: the degrees of freedom value 1 is too large for this example program"));

  return PRNG->AsChiSquared(INT(Value1));
}

double __fastcall TForm1::GetErlang()
{
  return PRNG->AsErlang(Value1, Value2);
}

double __fastcall TForm1::GetExponential()
{
  return PRNG->AsExponential(Value1);
}

double __fastcall TForm1::GetF()
{
  if (Value1 > 65535.0)
    throw(Exception(
      "TForm1.GetF: the degrees of freedom value 1 is too large for this example program"));
  if (Value2 > 65535.0)
    throw(Exception(
      "TForm1.GetF: the degrees of freedom value 2 is too large for this example program"));
  return PRNG->AsF(INT(Value1), INT(Value2));
}

double __fastcall TForm1::GetGamma()
{
  return PRNG->AsGamma(Value1, Value2);
}

double __fastcall TForm1::GetLogNormal()
{
  return PRNG->AsLogNormal(Value1, Value2);
}

double __fastcall TForm1::GetNormal()
{
  return PRNG->AsNormal(Value1, Value2);
}

double __fastcall TForm1::GetT()
{
  if (Value1 > 65535.0)
    throw(Exception(
      "TForm1.GetT: the degrees of freedom value is too large for this example program"));
  return PRNG->AsT(INT(Value1));
}

double __fastcall TForm1::GetUniform()
{
  return PRNG->AsFloat();
}

double __fastcall TForm1::GetWeibull()
{
  return PRNG->AsWeibull(Value1, Value2);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnGenerateClick(TObject *Sender)
{
  if (edtParm1->Text.IsEmpty())
    Value1 = 0.0;
  else
    Value1 = StrToFloat(edtParm1->Text);
  if (edtParm2->Text.IsEmpty())
    Value2 = 0.0;
  else
    Value2 = StrToFloat(edtParm2->Text);
  GenerateGraph(cboDist->ItemIndex);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::GenerateGraph(int aDistInx)
{
  #define RandomCount 1000000

  int Buckets[401];
  int i;
  double R;
  int Inx;
  int MaxHt;
  double MaxLineFactor;
  double GraphWidth;
  int OldPercent;
  int NewPercent;
  double MaxY;

  // zero out the buckets
  ZeroMemory(Buckets, sizeof(Buckets));

  // calculate random numbers according to distribution, convert to a
  // bucket index, and increment that bucket count
  OldPercent = -1;
  GraphWidth = imgGraph->Width;
  for (i = 0; i < RandomCount; i++) {
    NewPercent = (i * 100) / RandomCount;
    if (NewPercent != OldPercent) {
      prgGenProgress->Position = NewPercent;
      OldPercent = NewPercent;
    }
    R = GetRandom();
    if (((double) GraphLeft <= R) && (R <= (double) GraphRight)) {
      Inx = INT((R - GraphLeft) * GraphWidth / (GraphRight - GraphLeft));
      if ((0 <= Inx) && (Inx <= 400))
        Buckets[Inx]++;
    }
  }

  // calculate the largest bucket
  MaxHt = 1;
  for (i = 0; i <= 400; i++) {
    if (MaxHt < Buckets[i])
      MaxHt = Buckets[i];
  }

  // draw the graph
  imgGraph->Canvas->Lock();
  try {
    imgGraph->Canvas->FillRect(Rect(0, 0, imgGraph->Width, imgGraph->Height));
    MaxLineFactor = (double) imgGraph->Height / MaxHt;
    imgGraph->Canvas->Pen->Color = clRed;
    for (i = 0; i <= 400; i++) {
      imgGraph->Canvas->PenPos = Point(i, imgGraph->Height);
      imgGraph->Canvas->LineTo(i, imgGraph->Height - INT(Buckets[i] * MaxLineFactor));
    }
  }
  __finally {
    imgGraph->Canvas->Unlock();
  }

  MaxY = (double) MaxHt / RandomCount;
  lblMaxY->Caption = Format("Max: %8.6f", ARRAYOFCONST((MaxY)));
}
//---------------------------------------------------------------------------

1	// *** BEGIN LICENSE BLOCK ***
2	// * Version: MPL 1.1
3	// *
4	// * The contents of this file are subject to the Mozilla Public License Version
5	// * 1.1 (the "License"); you may not use this file except in compliance with
6	// * the License. You may obtain a copy of the License at
7	// * http://www.mozilla.org/MPL/
8	// *
9	// * Software distributed under the License is distributed on an "AS IS" basis,
10	// * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11	// * for the specific language governing rights and limitations under the
12	// * License.
13	// *
14	// * The Original Code is TurboPower SysTools
15	// *
16	// * The Initial Developer of the Original Code is
17	// * TurboPower Software
18	// *
19	// * Portions created by the Initial Developer are Copyright (C) 1996-2002
20	// * the Initial Developer. All Rights Reserved.
21	// *
22	// * Contributor(s):
23	// *
24	// * *** END LICENSE BLOCK ***
25	//---------------------------------------------------------------------------
26	#include <vcl.h>
27	#pragma hdrstop
28
29	#include "ExRndU.h"
30	//---------------------------------------------------------------------------
31	#pragma link "strandom"
32	#pragma package(smart_init)
33	#pragma resource "*.dfm"
34	TForm1 *Form1;
35
36	const
37	AnsiString DistNames[12] = {
38	"Beta", "Cauchy", "ChiSquared", "Erlang", "Exponential",
39	"F", "Gamma", "LogNormal", "Normal", "Student's t",
40	"Uniform", "Weibull"};
41
42
43	//---------------------------------------------------------------------------
44	__fastcall TForm1::TForm1(TComponent* Owner)
45	: TForm(Owner)
46	{
47	}
48	//---------------------------------------------------------------------------
49	void __fastcall TForm1::FormCreate(TObject *Sender)
50	{
51	int i;
52	int UniformInx;
53
54	cboDist->Items->Clear();
55	UniformInx = -1;
56	for (i = 0; i < 12; i++) {
57	cboDist->Items->Add(DistNames[i]);
58	if (DistNames[i].AnsiCompare("Uniform") == 0)
59	UniformInx = i;
60	}
61	cboDist->ItemIndex = UniformInx;
62	cboDistChange(this);
63	PRNG = new TStRandomSystem(0);
64	}
65	//---------------------------------------------------------------------------
66	void __fastcall TForm1::FormDestroy(TObject *Sender)
67	{
68	delete PRNG;
69	}
70	//---------------------------------------------------------------------------
71	void __fastcall TForm1::cboDistChange(TObject *Sender)
72	{
73	switch (cboDist->ItemIndex) {
74	case 0 : PrepForBeta(); break;
75	case 1 : PrepForCauchy(); break;
76	case 2 : PrepForChiSquared(); break;
77	case 3 : PrepForErlang(); break;
78	case 4 : PrepForExponential(); break;
79	case 5 : PrepForF(); break;
80	case 6 : PrepForGamma(); break;
81	case 7 : PrepForLogNormal(); break;
82	case 8 : PrepForNormal(); break;
83	case 9 : PrepForT(); break;
84	case 10: PrepForUniform(); break;
85	case 11: PrepForWeibull(); break;
86	}
87	updRightClick(this, btNext);
88	updLeftClick(this, btNext);
89	edtParm1->Text = FloatToStr(Value1);
90	edtParm2->Text = FloatToStr(Value2);
91
92	}
93	//---------------------------------------------------------------------------
94	void __fastcall TForm1::updRightClick(TObject *Sender, TUDBtnType Button)
95	{
96	lblRight->Caption = IntToStr(updRight->Position);
97	GraphRight = updRight->Position;
98	}
99	//---------------------------------------------------------------------------
100	void __fastcall TForm1::updLeftClick(TObject *Sender, TUDBtnType Button)
101	{
102	lblLeft->Caption = IntToStr(updLeft->Position);
103	GraphLeft = updLeft->Position;
104	}
105	//---------------------------------------------------------------------------
106	void __fastcall TForm1::PrepForBeta()
107	{
108	lblParm1->Caption = "Shape 1:";
109	lblParm1->Visible = true;
110	lblParm2->Caption = "Shape 2:";
111	lblParm2->Visible = true;
112	edtParm1->Visible = true;
113	edtParm1->Enabled = true;
114	edtParm2->Visible = true;
115	edtParm2->Enabled = true;
116	updLeft->Position = 0;
117	updRight->Position = 1;
118	Value1 = 2.0;
119	Value2 = 4.0;
120	GetRandom = GetBeta;
121	}
122
123	void __fastcall TForm1::PrepForCauchy()
124	{
125	lblParm1->Caption = "(none)";
126	lblParm1->Visible = true;
127	lblParm2->Visible = false;
128	edtParm1->Visible = false;
129	edtParm1->Enabled = false;
130	edtParm2->Visible = false;
131	edtParm2->Enabled = false;
132	updLeft->Position = -5;
133	updRight->Position = 5;
134	Value1 = 0.0;
135	Value2 = 0.0;
136	GetRandom = GetCauchy;
137	}
138
139	void __fastcall TForm1::PrepForChiSquared()
140	{
141	lblParm1->Caption = "Degrees of freedom:";
142	lblParm1->Visible = true;
143	lblParm2->Visible = false;
144	edtParm1->Visible = true;
145	edtParm1->Enabled = true;
146	edtParm2->Visible = false;
147	edtParm2->Enabled = false;
148	updLeft->Position = 0;
149	updRight->Position = 20;
150	Value1 = 5.0;
151	Value2 = 0.0;
152	GetRandom = GetChiSquared;
153	}
154
155	void __fastcall TForm1::PrepForErlang()
156	{
157	lblParm1->Caption = "Mean:";
158	lblParm1->Visible = true;
159	lblParm2->Caption = "Order:";
160	lblParm2->Visible = true;
161	edtParm1->Visible = true;
162	edtParm1->Enabled = true;
163	edtParm2->Visible = true;
164	edtParm2->Enabled = true;
165	updLeft->Position = 0;
166	updRight->Position = 5;
167	Value1 = 1.0;
168	Value2 = 4.0;
169	GetRandom = GetErlang;
170	}
171
172	void __fastcall TForm1::PrepForExponential()
173	{
174	lblParm1->Caption = "Mean:";
175	lblParm1->Visible = true;
176	lblParm2->Visible = false;
177	edtParm1->Visible = true;
178	edtParm1->Enabled = true;
179	edtParm2->Visible = false;
180	edtParm2->Enabled = false;
181	updLeft->Position = 0;
182	updRight->Position = 10;
183	Value1 = 1.0;
184	Value2 = 0.0;
185	GetRandom = GetExponential;
186	}
187
188	void __fastcall TForm1::PrepForF()
189	{
190	lblParm1->Caption = "Degrees of freedom 1:";
191	lblParm1->Visible = true;
192	lblParm2->Caption = "Degrees of freedom 2:";
193	lblParm2->Visible = true;
194	edtParm1->Visible = true;
195	edtParm1->Enabled = true;
196	edtParm2->Visible = true;
197	edtParm2->Enabled = true;
198	updLeft->Position = 0;
199	updRight->Position = 20;
200	Value1 = 10.0;
201	Value2 = 5.0;
202	GetRandom = GetF;
203	}
204
205	void __fastcall TForm1::PrepForGamma()
206	{
207	lblParm1->Caption = "Shape:";
208	lblParm1->Visible = true;
209	lblParm2->Caption = "Scale:";
210	lblParm2->Visible = true;
211	edtParm1->Visible = true;
212	edtParm1->Enabled = true;
213	edtParm2->Visible = true;
214	edtParm2->Enabled = true;
215	updLeft->Position = 0;
216	updRight->Position = 10;
217	Value1 = 2.0;
218	Value2 = 1.0;
219	GetRandom = GetGamma;
220	}
221
222	void __fastcall TForm1::PrepForLogNormal()
223	{
224	lblParm1->Caption = "Mean:";
225	lblParm1->Visible = true;
226	lblParm2->Caption = "Standard deviation:";
227	lblParm2->Visible = true;
228	edtParm1->Visible = true;
229	edtParm1->Enabled = true;
230	edtParm2->Visible = true;
231	edtParm2->Enabled = true;
232	updLeft->Position = 0;
233	updRight->Position = 10;
234	Value1 = 0.0;
235	Value2 = 1.0;
236	GetRandom = GetLogNormal;
237	}
238
239	void __fastcall TForm1::PrepForNormal()
240	{
241	lblParm1->Caption = "Mean:";
242	lblParm1->Visible = true;
243	lblParm2->Caption = "Standard deviation:";
244	lblParm2->Visible = true;
245	edtParm1->Visible = true;
246	edtParm1->Enabled = true;
247	edtParm2->Visible = true;
248	edtParm2->Enabled = true;
249	updLeft->Position = -5;
250	updRight->Position = 5;
251	Value1 = 0.0;
252	Value2 = 1.0;
253	GetRandom = GetNormal;
254	}
255
256	void __fastcall TForm1::PrepForT()
257	{
258	lblParm1->Caption = "Degrees of freedom:";
259	lblParm1->Visible = true;
260	lblParm2->Visible = false;
261	edtParm1->Visible = true;
262	edtParm1->Enabled = true;
263	edtParm2->Visible = false;
264	edtParm2->Enabled = false;
265	updLeft->Position = -10;
266	updRight->Position = 10;
267	Value1 = 10.0;
268	Value2 = 0.0;
269	GetRandom = GetT;
270	}
271
272	void __fastcall TForm1::PrepForUniform()
273	{
274	lblParm1->Caption = "(none)";
275	lblParm1->Visible = true;
276	lblParm2->Visible = false;
277	edtParm1->Visible = false;
278	edtParm1->Enabled = false;
279	edtParm2->Visible = false;
280	edtParm2->Enabled = false;
281	updLeft->Position = 0;
282	updRight->Position = 1;
283	Value1 = 0.0;
284	Value2 = 0.0;
285	GetRandom = GetUniform;
286	}
287
288	void __fastcall TForm1::PrepForWeibull()
289	{
290	lblParm1->Caption = "Shape:";
291	lblParm1->Visible = true;
292	lblParm2->Caption = "Scale:";
293	lblParm2->Visible = true;
294	edtParm1->Visible = true;
295	edtParm1->Enabled = true;
296	edtParm2->Visible = true;
297	edtParm2->Enabled = true;
298	updLeft->Position = 0;
299	updRight->Position = 10;
300	Value1 = 2.0;
301	Value2 = 3.0;
302	GetRandom = GetWeibull;
303	}
304
305	double __fastcall TForm1::GetBeta()
306	{
307	return PRNG->AsBeta(Value1, Value2);
308	}
309
310	double __fastcall TForm1::GetCauchy()
311	{
312	return PRNG->AsCauchy();
313	}
314
315	double __fastcall TForm1::GetChiSquared()
316	{
317	if (Value1 > 65535.0)
318	throw(Exception(
319	"TForm1.GetChiSquared: the degrees of freedom value 1 is too large for this example program"));
320
321	return PRNG->AsChiSquared(INT(Value1));
322	}
323
324	double __fastcall TForm1::GetErlang()
325	{
326	return PRNG->AsErlang(Value1, Value2);
327	}
328
329	double __fastcall TForm1::GetExponential()
330	{
331	return PRNG->AsExponential(Value1);
332	}
333
334	double __fastcall TForm1::GetF()
335	{
336	if (Value1 > 65535.0)
337	throw(Exception(
338	"TForm1.GetF: the degrees of freedom value 1 is too large for this example program"));
339	if (Value2 > 65535.0)
340	throw(Exception(
341	"TForm1.GetF: the degrees of freedom value 2 is too large for this example program"));
342	return PRNG->AsF(INT(Value1), INT(Value2));
343	}
344
345	double __fastcall TForm1::GetGamma()
346	{
347	return PRNG->AsGamma(Value1, Value2);
348	}
349
350	double __fastcall TForm1::GetLogNormal()
351	{
352	return PRNG->AsLogNormal(Value1, Value2);
353	}
354
355	double __fastcall TForm1::GetNormal()
356	{
357	return PRNG->AsNormal(Value1, Value2);
358	}
359
360	double __fastcall TForm1::GetT()
361	{
362	if (Value1 > 65535.0)
363	throw(Exception(
364	"TForm1.GetT: the degrees of freedom value is too large for this example program"));
365	return PRNG->AsT(INT(Value1));
366	}
367
368	double __fastcall TForm1::GetUniform()
369	{
370	return PRNG->AsFloat();
371	}
372
373	double __fastcall TForm1::GetWeibull()
374	{
375	return PRNG->AsWeibull(Value1, Value2);
376	}
377	//---------------------------------------------------------------------------
378	void __fastcall TForm1::btnGenerateClick(TObject *Sender)
379	{
380	if (edtParm1->Text.IsEmpty())
381	Value1 = 0.0;
382	else
383	Value1 = StrToFloat(edtParm1->Text);
384	if (edtParm2->Text.IsEmpty())
385	Value2 = 0.0;
386	else
387	Value2 = StrToFloat(edtParm2->Text);
388	GenerateGraph(cboDist->ItemIndex);
389	}
390	//---------------------------------------------------------------------------
391	void __fastcall TForm1::GenerateGraph(int aDistInx)
392	{
393	#define RandomCount 1000000
394
395	int Buckets[401];
396	int i;
397	double R;
398	int Inx;
399	int MaxHt;
400	double MaxLineFactor;
401	double GraphWidth;
402	int OldPercent;
403	int NewPercent;
404	double MaxY;
405
406	// zero out the buckets
407	ZeroMemory(Buckets, sizeof(Buckets));
408
409	// calculate random numbers according to distribution, convert to a
410	// bucket index, and increment that bucket count
411	OldPercent = -1;
412	GraphWidth = imgGraph->Width;
413	for (i = 0; i < RandomCount; i++) {
414	NewPercent = (i * 100) / RandomCount;
415	if (NewPercent != OldPercent) {
416	prgGenProgress->Position = NewPercent;
417	OldPercent = NewPercent;
418	}
419	R = GetRandom();
420	if (((double) GraphLeft <= R) && (R <= (double) GraphRight)) {
421	Inx = INT((R - GraphLeft) * GraphWidth / (GraphRight - GraphLeft));
422	if ((0 <= Inx) && (Inx <= 400))
423	Buckets[Inx]++;
424	}
425	}
426
427	// calculate the largest bucket
428	MaxHt = 1;
429	for (i = 0; i <= 400; i++) {
430	if (MaxHt < Buckets[i])
431	MaxHt = Buckets[i];
432	}
433
434	// draw the graph
435	imgGraph->Canvas->Lock();
436	try {
437	imgGraph->Canvas->FillRect(Rect(0, 0, imgGraph->Width, imgGraph->Height));
438	MaxLineFactor = (double) imgGraph->Height / MaxHt;
439	imgGraph->Canvas->Pen->Color = clRed;
440	for (i = 0; i <= 400; i++) {
441	imgGraph->Canvas->PenPos = Point(i, imgGraph->Height);
442	imgGraph->Canvas->LineTo(i, imgGraph->Height - INT(Buckets[i] * MaxLineFactor));
443	}
444	}
445	__finally {
446	imgGraph->Canvas->Unlock();
447	}
448
449	MaxY = (double) MaxHt / RandomCount;
450	lblMaxY->Caption = Format("Max: %8.6f", ARRAYOFCONST((MaxY)));
451	}
452	//---------------------------------------------------------------------------
453