Question

I am porting a home-brew report Delphi reporting solution into FastReport and I’ve come to the need for a chart showing the distribution of a field in a dataset (A ‘Bell curve’ or normal distribution). Previously I wrote code to sort field values into cells (eg 100 say) and then plotted a TChart histogram of cell counts (Y) against 1-100 (X). FastReport has good integration with TChart and I am plotting lines of field values easily. Is there an existing means of plotting a distribution chart or should I create a new data set of sorted cells and plot that?
Thanks.

Answer 1

When I realised that there was no direct solution to this, I created a class which others might find useful. It takes a data set and does all the hard work of building a list of frequency cells for a specific field name and then cacheing this to allow a ‘GetValue’ call from a TfrxUserDataSet called ‘Distributions’. The report user can then simply drop a bar chart in the report, nominate ‘Distributions’ as the data set and choose the required field for ‘Y values’. ‘X values’ must be set to the same field name but with ‘-X’ appended – my class then transparently returns X and Y values for the chart having built the frequency cells on the first call. No FastReport code is involved.

Although working, this is fledgling code and could be improved further, for example at present the X values span min to max. A better display would be to use 3 or 6-sigma (standard deviation) but this is easy to modify.

unit UartFastReportsDistribution;
interface

uses
  DB,
  Classes;

const
  CellCount = 101;

type
  TCellArray = array[0..CellCount-1] of integer;
  TXValues   = array[0..CellCount-1] of double;

  TDistributionCells = class( TObject )
    constructor Create( ADataSet : TDataSet; const AFieldName : string );
  PRIVATE
    FDataSet : TDataSet;
    FFieldName : string;
    FCells : TCellArray;
    FLastRecNo : integer;
    FCellsMax : integer;
    FDataMin, FDataMax : double;
    procedure BuildCells;
    function  XValue( AIndex : integer ) : double;
    function  YValue( AIndex : integer ) : double;
    function  DataMean : double;
    function  DataDevPk : double;
  end;


  TArtFastReportsDistribution = class( TObject )
    constructor Create( ADataSet : TDataSet );
    destructor Destroy; override;
  private
    FDataSet : TDataSet;
    FDistributions : TStringList;

    function  NameToDistribution( const AFieldName: string) : TDistributionCells;
  PUBLIC
    procedure DoGetData( const AFieldName: string; ARecNo : integer; var Value: Variant);
    function  RecordCount : integer;
  end;

implementation

uses
  Math,
  SysUtils;

{ TArtFastReportsDistribution }

function TArtFastReportsDistribution.NameToDistribution( const AFieldName: string) : TDistributionCells;
var
  I : integer;
begin
  I := FDistributions.IndexOf( AFieldName );
  if I = -1 then
    begin
    Result := TDistributionCells.Create( FDataSet, AFieldName );
    FDistributions.AddObject( AfieldName, Result );
    end
   else
    Result := FDistributions.Objects[I] as TDistributionCells;
end;


constructor TArtFastReportsDistribution.Create(ADataSet: TDataSet);
begin
  inherited Create;
  FDataSet := ADataSet;
  FDistributions := TStringList.Create;
  FDistributions.OwnsObjects := True;
end;

destructor TArtFastReportsDistribution.Destroy;
begin
  FreeAndNil( FDistributions );
  inherited;
end;

procedure TArtFastReportsDistribution.DoGetData(const AFieldName: string;
  ARecNo : integer; var Value: Variant);

var
  sFieldName : string;
  bIsXValue  : boolean;
  I          : integer;
  Dist       : TDistributionCells;
begin
  sFieldName := AFieldName;
  I := Pos( '-X', sFieldName );
  bIsXValue := I > 0;
  if bIsXValue then
    Delete( sFieldName, I, MaxInt );

  Dist := NameToDistribution( sFieldName );

  If (ARecNo = 1) and (Dist.FLastRecNo <> 1) then
    Dist.BuildCells;

  Dist.FLastRecNo := ARecNo;

  if bIsXValue then
    Value := Dist.XValue(ARecNo-1)
   else
    Value := Dist.YValue(ARecNo-1);
end;


function TArtFastReportsDistribution.RecordCount: integer;
begin
  Result := CellCount;
end;

{ TDistributionCells }


{ TDistributionCells }

procedure TDistributionCells.BuildCells;

  procedure ClearCells;
  var
    I : integer;
  begin
    for I := 0 to CellCount-1 do
      FCells[I] := 0;

    FCellsMax := 0;
    FDataMin := 0.0;
    FDataMax := 0.0;
  end;


  function GetDataSetFieldValues : TFloatArray;
  var
    I : integer;
    Field : TField;
  begin
    Field := FDataSet.FieldByName( FFieldName );
    if not Assigned( Field ) then
      Raise Exception.CreateFmt( 'Missing distribution field "%s"', [FFieldName] );

    SetLength( Result, FDataSet.RecordCount );
    FDataSet.First;
    I := 0;
    While not FDataset.EOF do
      begin
      Result[I] := Field.AsFloat;
      Inc(I);
      FDataSet.Next;
      end;
  end;


var
  I,
  iCellCount,
  iOffset : integer;
  F : double;
  Data : TFloatArray;
begin
  ClearCells;

  If FDataSet.RecordCount = 0 then
    Exit;

  Data := GetDataSetFieldValues;

  FDataMin  := MinValue( Data );
  FDataMax  := MaxValue( Data );

  FCellsMax := 0;
  iCellCount   := Length( FCells );

  for I := 0 to Length( Data )-1 do
    begin
    F := Data[I];

    F := (F - DataMean + DataDevPk)/(2*DataDevPk);
    iOffset := Trunc( iCellCount * F );
    If iOffset < 0 then
      iOffset := 0
     else
      If iOffset > iCellCount-1 then
       iOffset := CellCount-1;
    FCells[iOffset] := FCells[iOffset] + 1;

    If I = 0 then
      FCellsMax := FCells[iOffset]
     else
      FCellsMax := Max( FCells[iOffset], FCellsMax );
    end;

end;


constructor TDistributionCells.Create(ADataSet: TDataSet;
  const AFieldName: string);
begin
  inherited Create;
  FDataSet := ADataSet;
  FFieldName := AFieldName;
end;

function TDistributionCells.DataDevPk: double;
begin
  Result := FDataMax - DataMean;
end;

function TDistributionCells.DataMean: double;
begin
  Result := (FDataMin + FDataMax) / 2;
end;

function TDistributionCells.XValue(AIndex: integer): double;
begin
  Result := AIndex;
  Result := (Result / CellCount) - 0.5;               
  Result := DataMean + (Result*2*DataDevPk);
end;

function TDistributionCells.YValue(AIndex: integer): double;
begin
//  Result := 100.0 * FCells[AIndex] / FCellsMax;
  Result := FCells[AIndex];
end;