» Delphi codeTiaon Lab - PHP, Delphi programming blog

Archive for the 'Delphi code' Category

Delphi code part 3 - Colours

Tuesday, March 6th, 2007

When I first started Delphi programming, I started with very basic stuff like number manipulation and string manipulation. This delphi unit I am going show you is a bit different, its smarter :). When I got tired of working with just numbers and strings, I started to play with colours. From the simple ones to more advanced ones.

For example, how grey colour appeared as RGB value, all the RGB values are equal. The higher the RGB value is the brighter the colour is, $FFFFFF is white, $000000 is black. I averaged two RGB values (compute R,G,B values sperately) to get an merged colour. I added values to RGB to make the colour brighter, and deducted values to make it darker.

Here is the code:

Show Code | Download colorman.pas

{ ---------------------------------------------------
Colour Manager Copyright (r) by DreamFactory
Version : 1.75 Author : William Yang
Last Update 09 - Sep - 97
--------------------------------------------------- }
unit ColorMan;
interface
uses Windows, SysUtils, Graphics, NumMan;
type
TRGB = array[0..2] of Byte;
PRGBArray = ^TRGBArray;
TRGBArray = array[0..2000] of TRGB;
//Common Used in Quick Basic
function QBColor (n:Integer) : TColor;
function ToQBColor (C: TColor) : Integer;
function HexToColor (Hex : String) : TColor; //Transfer Hexidecimal to Color
function HexToInt (Hex : String) : Integer; //Transfer Hexidecimal to Integer
function BrightenColor(BaseColor: TColor; Adjust : Integer): TColor;
//Convert the BaseColor to the Grade of Adjust Brighten Color
function DarkenColor(BaseColor: TColor; Adjust : Integer): TColor;
//Convert the BaseColor to the Grade of Adjust Darken Color
function ColorToGrey(SC : TColor) : TColor; //Convert the SC to Grey Color
function Colorise(SC, MC : TColor) : TColor; //Convert the SC to MC Color
function ERGB(R,G,B : Single) : TColor; //Error RGB Color
function CorrectColor(C : Single) : Integer; //Correct the Wrong Color Byte
function MergeColor(C1, C2 : TColor) : TColor; //Merge Two Color to One
function MiscColor(var C : Variant) : TColor; //Misc A Number of Colors To One
function MiscBmpToColor(SDC : Integer; W, H : Integer; A : TRect) : TColor;
//Misc A Whole BMP to One Color
function IsGreyColor(C : TColor) : Boolean; //Check if the Color is grey color
function IsLightColor(C : TColor) : Boolean; //Check if the Color is Light Color
{Added 19-March-1997}
function RGBAvg(C : TColor) : Integer;
function SumRGB(C : TColor) : Integer;
function CompareR(C1, C2 : TColor) : Integer;
function CompareG(C1, C2 : TColor) : Integer;
function CompareB(C1, C2 : TColor) : Integer;
function CompareColor(C1, C2 : TColor) : Integer;
function ColorAdd(C1, C2 : TColor) : TColor;
function ColorMinus(C1, C2 : TColor) : TColor;
function InvertColor(C: TColor) : TColor;
function CentreRGB(C : TColor; Percent : Integer) : TColor;
// 10 July 1997
function MergeColorExt(C1, C2 : TColor; Grade: Byte) : TColor;
function AutoBW(BGColor: TColor): TColor;
procedure DeColor(Color: TColor; var R, G, B: Integer);
// 16 Oct 1997
procedure DeColorB(Color: TColor; var R, G, B: Byte);
//1/10/98
function RGBToInt(aRGB: TRGB): Integer;
function IntToRGB(Int: Integer): TRGB;
// 11/10/98
function EnhanceColor(Color: TColor; Grade: Integer): TColor;
implementation
function IsNearColor(Color, CompareTo: TColor; AllowNear: Integer): BOolean;
var
r,g,b: Integer;
r1,g1,b1: Integer;
begin
decolor(color, r, g, b);
decolor(CompareTo, r1, g1, b1);
if (r in [r1-allownear..r1+allownear]) and (b in [b1-allownear..b1+allownear]) and
(g in [g1-allownear..g1+allownear]) then
Result := True
else
Result := False;
end;
function EnhanceColor(Color: TColor; Grade: Integer): TColor;
var
av, r, g, b: Integer;
begin
DeColor(Color, r, g, b);
av := (r + g + b) div 3;
{ if r > av then Inc(r, Grade) else Dec(r, Grade);
if g > av then Inc(g, Grade) else Dec(g, Grade);
if b > av then Inc(b, Grade) else Dec(b, Grade);}
r := Round(r + (av - r)*(Grade/100));
g := Round(g + (av - g)*(Grade/100));
b := Round(b + (av - b)*(Grade/100));
Result := ERGB(r, g, b);
end;
function RGBToInt(aRGB: TRGB): Integer;
begin
Result := RGB(aRGB[2], aRGB[1], aRGB[0]);
end;
function IntToRGB(Int: Integer): TRGB;
begin
Result[0] := GetBValue(Int);
Result[1] := GetGValue(Int);
Result[2] := GetRValue(Int);
end;
procedure DeColor(Color: TColor; var R, G, B: Integer);
begin
R := GetRValue(Color);
G := GetGValue(Color);
B := GetBValue(Color);
end;
procedure DeColorB(Color: TColor; var R, G, B: Byte);
begin
R := GetRValue(Color);
G := GetGValue(Color);
B := GetBValue(Color);
end;
function ToQBColor (C: TColor) : Integer;
var
i : Byte;
begin
Result := 0;
for i := 0 to 15 do
begin
if C =QBColor(i) then
begin
Result := i;
Exit;
end;
end;
end;
function AutoBW(BGColor: TColor): TColor;
begin
if IsLightColor(BGColor) then
Result := clBlack
else
Result := clWhite;
end;
function CentreRGB(C : TColor; Percent : Integer) : TColor;
var
Avg : Integer;
R, G, B : Integer;
begin
Avg := RGBAvg(C);
R := GetRValue(C);
G := GetGValue(C);
B := GetBValue(C);
R := R - (R - Avg) * Percent;
G := G - (G - Avg) * Percent;
B := B - (B - Avg) * Percent;
Result := RGB(R,G,B);
end;
function InvertColor(C: TColor) : TColor;
begin
Result := RGB(255 - GetRValue(C), 255 - GetGValue(C), 255 - GetBValue(C));
end;
function ColorAdd(C1, C2 : TColor) : TColor;
begin
Result := ERGB(GetRValue(C1) + GetRValue(C2), GetGValue(C1) + GetGValue(C2),
GetBValue(C1) + GetBValue(C2));
end;
function ColorMinus(C1, C2 : TColor) : TColor;
begin
Result := ERGB(GetRValue(C1) - GetRValue(C2), GetGValue(C1) - GetGValue(C2),
GetBValue(C1) - GetBValue(C2));
end;
function CompareR(C1, C2 : TColor) : Integer;
begin
Result := GetRValue(C1) - GetRValue(C2);
end;
function CompareG(C1, C2 : TColor) : Integer;
begin
Result := GetGValue(C1) - GetGValue(C2);
end;
function CompareB(C1, C2 : TColor) : Integer;
begin
Result := GetBValue(C1) - GetBValue(C2);
end;
function CompareColor(C1, C2 : TColor) : Integer;
begin
Result := RGBAvg(C1) - RGBAvg(C2);
end;
function SumRGB(C : TColor) : Integer;
begin
Result := GetRValue(C) + GetGValue(C) + GetBValue(C);
end;
function RGBAvg(C : TColor) : Integer;
begin
Result := SumRGB(C) div 3;
end;
function IsLightColor(C : TColor) : Boolean;
var
Count : Integer;
begin
Count := 0;
{ Check if any of these value is more than a half of 255 }
C := ColorToGrey(C);
if GetRValue(C) < 128 then Count := Count + 1;
if GetGValue(C) < 128 then Count := Count + 1;
if GetBValue(C) < 128 then Count := Count + 1;
{-------------------------------------------
| 0 |---|---|---|---| 255 |
| Black White |
-------------------------------------------}
if Count > 1 then
Result := False
else
Result := True;
end;
function IsGreyColor(C : TColor) : Boolean;
begin
{A Grey Color is combined with eque R,G,B Value}
{Check if Red = Green, Blue = Green }
if (GetRValue(C) = GetGValue(C)) and (GetBValue(C) = GetGValue(C)) then
Result := True
else
Result := False;
end;
{
This function is written after the MiscColor, because I thought the Variant
Parameter Make the tranfering too slow.
}
function MiscBmpToColor(SDC : Integer; W, H : Integer; A : TRect) : TColor;
var
C, k, i, j : Integer;
pR, pG, pB : LongInt;
begin
K := 0; pR := 0; pG := 0; pB := 0;
for i := A.Left to A.Right do
for j := A.Top to A.Bottom do
begin
if not ((i < 0) or (j <= 0) or (i > W) or (j > H)) then
begin
C := GetPixel(SDC, i, j);
Inc(pR, GetRValue(C));
Inc(pG, GetGValue(C));
inc(pB, GetBValue(C));
k := k + 1;
end;
end;
pR := Round( pR / k );
pB := Round( pB / k );
pG := Round( pG / k );
Result := RGB(pR, pG, pB);
end;
function MergeColor(C1, C2 : TColor) : TColor;
begin
Result := MergeColorExt(C1, C2, 50);
end;
function MergeColorExt(C1, C2 : TColor; Grade: Byte) : TColor;
var
pR, pG, pB : Single;
begin
pR := (GetRValue(C1) * Grade / 100 + GetRValue(C2) * (100-Grade) / 100);
pG := (GetGValue(C1) * Grade / 100 + GetGValue(C2) * (100-Grade) / 100);
pB := (GetBValue(C1) * Grade / 100 + GetBValue(C2) * (100-Grade) / 100);
Result := ERGB(pR, pG, pB);
end;
function MiscColor(var C : Variant) : TColor;
var
pR, pG, pB : LongInt;
Count, i, l, h : Integer;
begin
end;
function CorrectColor(C : Single) : Integer;
begin
Result := Round(C);
if Result > 255 then Result := 255;
if Result < 0 then Result := 0;
end;
function ERGB(R,G,B : Single) : TColor;
begin
Result := RGB(CorrectColor(R), CorrectColor(G), CorrectColor(B));
end;
function Colorise(SC, MC : TColor) : TColor;
var
pR, pG, pB : Single;
begin
// take the each percentage of r, g, b in the given color
pR := GetRValue(MC) / 255 + 1;
pG := GetGValue(MC) / 255 + 1;
pB := GetBValue(MC) / 255 + 1;
Result := ColorToGrey(SC);
Result := ERGB(pR * GetRValue(Result), pG * GetGValue(Result), pB * GetBValue(Result));
end;
function ColorToGrey(SC : TColor) : TColor;
var
avg : Integer;
begin
avg := Round((GetRValue(SC) * 20 + GetGValue(SC) * 50 + GetBValue(SC)*30)/100);
Result := RGB(avg, avg, avg);
end;
function QBColor (n:Integer):TColor;
var
C:TColor;
begin
case n of
0: C := 0;
1: C := clNavy;
2: C := 32768;
3: C := 8421376;
4: C := 128;
5: C := 8388736;
6: C := 32896;
7: C := 12632256;
8: C := 8421504;
9: C := 16711680;
10: C := 65280;
11: C := 16776960;
12: C := 255;
13: C := 16711935;
14: C := clYellow;
15: C := clWhite;
end;
Result := C;
end;
function HexToColor(Hex:String) : TColor;
var
RHex : string;
begin
RHex := '$' + Hex;
Result := StrToInt(RHex);
end;
function HexToInt(Hex:String) : Integer;
var
RHex : string;
begin
RHex := '$' + Hex;
Result := StrToInt(RHex);
end;
function BrightenColor(BaseColor: TColor; Adjust : Integer): TColor;
begin
BaseColor := ColorToRGB(BaseColor);
Result := ERGB(GetRValue(BaseColor) + Adjust, GetGValue(BaseColor) + Adjust,
GetBValue(BaseColor) + Adjust);
end;
function DarkenColor(BaseColor: TColor; Adjust : Integer): TColor;
begin
Result := BrightenColor(BaseColor, -Adjust);
end;
end.

Posted in Delphi, Delphi code | No Comments »

Delphi code part 2 - Strings

Tuesday, March 6th, 2007

Here is the part of my old delphi codes, its a unit I use frequently for string manipulation. Some are out of date, newer version of Delphi comes with better codes, same are not as smart as other units written by smart Russians, like faststrings, etc. None the less, they are useful if you like to learn the basics of Delphi or Pascal.

Show Code | Download StrMan.pas

{ ---------------------------------------------------
String Manager Copyright (r) by DreamFactory
Version : 1.75 Author : William Yang
Last Update 25 - Aug - 97
--------------------------------------------------- }
unit StrMan; {String Manager}
interface
{-- Declaretion Part --}
uses Windows, SysUtils, Math, Classes, Registry;
type
TCharSet = set of Char;
const
Decimals = ['0'..'9'];
FloatNums = ['0'..'9', '.'];
Operators = ['+', '-', '*', '/'];
HexDecimals = ['0'..'9', 'A'..'F'];
Letters = ['a'..'z', 'A'..'Z'];
Symbols = ['"', '''', '<', '>', '{', '}', '[', ']', '(', ',', ')'];
Masks : array[1..3] of Char = ('*', '?', '#');
function ReplaceOne(Src, Ch : String; iStart, iCount : Integer ) : String;
function FillStr(Amount : Byte; C : Char) : String;
function TitleCase(SourceStr : String) : String;
function ReplaceAll(Source , Target, ChangeTo : String) : String ;
function Instr(iStart : Integer; Src, Find: String) : Integer;
function CompareStrAry(Source : String; CmpTo : Array of string) : Integer;
function LowCaseStr(S : String) : String;
function LoCase(C : Char) : Char;
procedure StrSplit(SrcStr : String; BreakDownPos : Integer;
var S1, S2 : String);
function LeftStr(S : String; ToPos : Integer) : String;
function RightStr(S : String; ToPos : Integer) : String;
function CharCount(S : String; C : Char) : Integer;
function RemoveChars(S : String; C : TCharSet) : String;
function StrBrief(AString: String; AMaxChar: Integer): String;
function EStrToInt(S : String) : Integer;
function EStrToFloat(S : String) : Real;
function LastDir(Dir: String): String;
function RPos(C: String; Src : String) : Integer; overload;
function RPos(C: String; Src : String; nStart: Integer) : Integer; overload;
function ReturnLine(SList: TStringList; Find: String) : String;
procedure SplitStrC (S:string; C : char; var head, queue : string);
procedure Split(StringList: TStringList; S : string; C : char);
function AppPath: String;
function ReadBetween(Src, Mark1, Mark2: String): String;
procedure RemoveQuate(var Src: String);
function strFileLoad(const aFile: String): String;
procedure strFileSave(const aFile,aString: String);
function JoinStrings(AStrings: TStrings): String; overload;
function JoinStrings(strings: TStrings; delimiter: String): String; overload;
function AddSlashes(AString: String): String;
function StripSlashes(AString: String): String;
implementation
function StrBrief(AString: String; AMaxChar: Integer): String;
begin
if Length(AString)<=AMaxChar then
Result := AString
else
begin
Result := Copy(AString, 0, AMaxChar-3) + '...';
end;
end;
function AddSlashes(AString: String): String;
begin
Result := ReplaceAll(AString, '''', '\''');
Result := ReplaceAll(Result, '"', '\"');
end;
function StripSlashes(AString: String): String;
begin
Result := ReplaceAll(AString, '\''', '''');
Result := ReplaceAll(Result, '\"', '"');
end;
function JoinStrings(AStrings: TStrings): String;
var
i: Integer;
begin
result := '';
for i := 0 to AStrings.Count-2 do
begin
result := result + AStrings[i] + '\';
end;
result := result + AStrings[AStrings.Count-1];
end;
function JoinStrings(strings: TStrings; delimiter: String): String;
var
i: Integer;
begin
if strings.Count=0 then Exit;
Result := strings[0];
if strings.Count>0 then
for i := 1 to strings.Count-1 do
begin
Result := Result + delimiter + strings[i]
end;
end;
function strFileLoad(const aFile: String): String;
var
aStr : TStrings;
begin
Result:='';
aStr:=TStringList.Create;
try
aStr.LoadFromFile(aFile);
Result:=aStr.Text;
finally
aStr.Free;
end;
end;
procedure strFileSave(const aFile,aString: String);
var
Stream: TStream;
begin
Stream := TFileStream.Create(aFile, fmCreate);
try
Stream.WriteBuffer(Pointer(aString)^,Length(aString));
finally
Stream.Free;
end;
end;
procedure RemoveQuate(var Src: String);
begin
if Src='' then Exit;
if Src[1]='"' then Delete(Src, 1, 1);
if Src[Length(Src)]='"' then Delete(Src, Length(Src), 1);
if Src[1]='''' then Delete(Src, 1, 1);
if Src[Length(Src)]='''' then Delete(Src, Length(Src), 1);
end;
function ReadBetween(Src, Mark1, Mark2: String): String;
var
i,j : Integer;
begin
if Mark1='' then i := 1 else i := Pos(Mark1, Src);
if Mark2='' then j := Length(Src) else j := InStr(i + Length(Mark1), Src, Mark2);
if j<=0 then j := Length(Src)+1;
if (i >0) and (j > 0) then
Result := Copy(Src, i + Length(Mark1), j-i-Length(Mark1));
end;
function AppPath: String;
begin
Result := ExtractFilepath(ParamStr(0));
end;
function LastDir(Dir: String): String;
begin
if Dir[Length(Dir)]='\' then
Delete(Dir, Length(Dir), 1);
Result := RightStr(Dir, RPos('\', Dir)+1);
end;
procedure SplitStrC (S:string; C : char; var head, queue : string);
var
I : integer;
Quated: Boolean;
begin
head:=''; queue:='';
Quated := False;
for i := 1 to Length(S) do // Iterate
begin
if S[i]='"' then
begin
if Quated then
begin
if head<>'' then Break;
Quated := False;
end
else
begin
if i=1 then Quated := True
end;
end
else if S[i]=C then
begin Break end
else
Head := Head + S[i];
end; // for
delete(S,1,i);
queue := S;
end;
procedure Split(StringList: TStringList; S : string; C : char);
var
Line: String;
begin
while S <> '' do
begin
SplitStrC(S, C, Line, S);
StringList.Add(Trim(Line));
end;
end;
function ReturnLine(SList: TStringList; Find: String) : String;
var
i :Integer;
s: String;
begin
Result := '';
for i := 0 to SList.Count - 1 do
begin
s := SList[i];
if Pos(Find, s) > 0 then
begin
Result := SList[i];
Exit;
end;
end;
end;
function EStrToFloat(S : String) : Real;
var
i : Integer;
r : String;
begin
r := '';
for i := 1 to Length(S) do
if s[i] in FloatNums then
r := r + s[i];
if r = '' then
Result := 0
else
Result := StrToFloat(r);
end;
function EStrToInt(S: String) : Integer;
var
i : Integer;
r : String;
begin
r := '';
for i := 1 to Length(S) do
if s[i] in Decimals then
r := r + s[i];
if r = '' then
Result := 0
else
Result := StrToInt(r);
end;
function RemoveChars(S : String; C : TCharSet) : String;
var
j : Integer;
begin
// Result := S;
j := 1;
Result := '';
while j <= Length(S) do
begin
if not (S[j] in C) then
Result := Result + S[j];
Inc(j);
end;
end;
function ReplaceOne(Src, Ch : String; iStart, iCount : Integer) : String;
var mResult : String;
begin
mResult := Src;
Delete(mResult, iStart, iCount);
Insert(Ch, mResult, iStart);
ReplaceOne := mResult;
end;
function Instr(iStart : Integer; Src, Find: String) : Integer;
var
CS : String;
begin
CS := Copy(Src, iStart, Length(Src)-iStart+1);
if Pos(Find, CS) <> 0 then
Result := Pos(Find, CS) + iStart - 1
else
Result := 0;
end;
function LeftStr(S : String; ToPos : Integer) : String;
begin
Result := Copy(S, 1, ToPos);
end;
function RightStr(S : String; ToPos : Integer) : String;
begin
Result := Copy(S, ToPos, Length(S) - ToPos + 1);
end;
procedure StrSplit(SrcStr : String; BreakDownPos : Integer;
var S1, S2 : String);
begin
S1 := LeftStr(SrcStr, BreakDownPos - 1);
S2 := RightStr(SrcStr, BreakDownPos - 1);
end;
function ReplaceAll(Source , Target, ChangeTo : String) : String ;
var
Index: Integer;
Src, Tgt, Cht : String;
begin
Src := Source;
Tgt := Target;
Cht := ChangeTo;
Index := Pos(Tgt, Src);
while Index > 0 do
begin
Src := ReplaceOne(Src, Cht, Index, Length(Tgt));
Index := Index + Length(Cht);
Index := Instr(Index, Src, Tgt);
end;
Result := Src;
end;
function LoCase(C : Char) : Char;
begin
if (Ord(C) >= Ord('A')) and (Ord(C) <= Ord('Z')) then
Result := Chr(Ord(C) - (Ord('A') - Ord('a')))
else LoCase := C;
end;
function LowCaseStr(S : String) : String;
var i : Integer;
begin
for i := 1 to Length(S) do
S[i] := LoCase(S[i]);
end;
{Make The First Letter Of Each Word To Upper Case}
function TitleCase(SourceStr : String) : String;
var
I : Integer;
First : boolean;
begin
Result := SourceStr;
First := True;
for I := 1 to Length(SourceStr) do
begin
if First then
Result[I] := UpCase(Result[I])
else
Result[I] := LoCase(Result[I]);
First := False;
if Result[I] in [' ', '=', '"', '''', ',', ';', '.'] then First := True;
end;
TitleCase := Result;
end;
{Fill The String With Parameter 'C'}
function FillStr(Amount : Byte; C : Char) : String;
var R : String;
i : byte;
begin
for i :=1 to Amount do
R := R + C;
Result := R;
end;
function CompareStrAry(Source : String; CmpTo : Array of string) : integer;
var i : Integer;
begin
Result := -1;
for i := Low(CmpTo) to High(CmpTo) do
begin
if LowCaseStr(Source) = LowCaseStr(CmpTo[i]) then
begin
Result := i;
Exit;
end;
end;
end;
function RPos(C: String; Src : String) : Integer;
begin
result := RPos(C, Src, 1);
end;
function RPos(C: String; Src : String; nStart: Integer) : Integer;
var
i : integer;
begin
Result := 0;
for i := Length(Src) downto nStart do
if Src[i] = C then
begin
Result := i;
Break;
end;
end;
function CharCount(S : String; C : Char) : Integer;
var i : Integer;
begin
Result := 0;
for i := 1 to Length(S) do
if S[i] = C then Result := Result + 1;
end;
end.

Posted in Delphi, Delphi code | No Comments »

Some useful Delphi codes part 1 - Numbers

Monday, March 5th, 2007

Over the years I have made quite a few software programs in Delphi, and inevitably I have also come up with many useful functions. Most of them I have never published on the Internet before, now I would like to list on blog.

Part 1 are functions for managing integer or real numbers, they were written very early in 1997.

Show Code | Download Numman.pas

{ ---------------------------------------------------
Numbers Manager Copyright (r) by
Version : 1.75 Author : William Yang
Last Update 24 - Aug - 97
--------------------------------------------------- }
unit NumMan;
interface
uses Classes, SysUtils, Windows;
// Force an integer number to be between certain range
function MakeBetween(S, nFrom, nTo : Integer) : Integer;
// Check if an integer is between n1 and n2
function Between(S, N1, N2 : Integer) : Boolean;
// Check if an real/float number is between n1 and n2
function fBetween(S, N1, N2 : Real) : Boolean;
// Calculate rectangular width
function RectWidth(Rect: TRect) : Integer;
// Calculate rectangular height
function RectHeight(Rect: TRect) : Integer;
// Find smallest integer in an array
function MinMost(Nums: array of Integer): Integer;
// Find largest integer in an array
function MaxMost(Nums: array of Integer): Integer;
// Check if the integers in an array are equal
function AllEqual(Nums: array of Integer): Boolean;
// Check if the integers in an array are different
function AllDiff(Nums: array of Integer): Boolean;
//Check if these numbers in the range
function AllBetween(Nums: array of Integer; nFrom, nTo : Integer): Boolean;
{Check if the numbers are like (1, 2, 3, 4, 5),
you can set InOrder to false if you want check(4,2,3,5,1) }
function IsIncreasement(Nums: array of Integer; InOrder: Boolean): Boolean;
{more customisable with amount that increase }
function IsIncreasementExt(Nums: array of Integer; InOrder: Boolean;
Incs: Integer): Boolean;
//Find a number an array of numbers, returns the index of the first catch.
function FindNum(Num: Integer; Nums: array of Integer): Integer;
//Find pairs, returns the total amount of pairs.
function FindPairs(Nums: array of Integer): Integer;
//Find the how many times the number appears.
function NumAppears(Num: Integer; Nums: array of Integer): Integer;
// A byte has 8 bits, ReadBits returns number value between certain bits in an integer
function ReadBits(Num, Start, Count: Integer): Integer;
// Returns how many bits are used to store this integer, e.g. 8 returns 4, 7 return 3