File Coverage

blib/lib/Finance/StockAccount.pm

Criterion	Covered	Total	%
statement	326	437	74.6
branch	72	112	64.2
condition	27	45	60.0
subroutine	41	52	78.8
pod	28	45	62.2
total	494	691	71.4

package Finance::StockAccount;

our $VERSION = '0.01';

use strict;
use warnings;

use Carp;
use POSIX;

use Finance::StockAccount::Set;
use Finance::StockAccount::AccountTransaction;
use Finance::StockAccount::Stock;



### Class definition
sub new {
    my ($class, $options) = @_;
    my $self = {
        sets                => {},
        skipStocks          => {},
        stats               => $class->getNewStatsHash(),
        allowZeroPrice      => 0,
        verbose             => 1,
    };
    if ($options and exists($options->{allowZeroPrice}) and $options->{allowZeroPrice}) {
        $self->{allowZeroPrice} = 1;
    }
    return bless($self, $class);
}

sub getNewStatsHash {
    return {
        stale                       => 1,
        startDate                   => undef,
        endDate                     => undef,
        maxCashInvested             => 0,
        totalOutlays                => 0,
        totalRevenues               => 0,
        profit                      => 0,
        profitOverOutlays           => 0,
        profitOverMaxCashInvested   => 0,
        profitOverYears             => 0,
        pomciOverYears              => 0,
        commissions                 => 0,
        regulatoryFees              => 0,
        otherFees                   => 0,
        numberOfTrades              => 0,
        numberExcluded              => 0,
        annualRatio                 => 0,
        annualStats                 => undef,
        annualStatsStale            => 1,
        quarterlyStats              => undef,
        quarterlyStatsStale         => 1,
        monthlyStats                => undef,
        monthlyStatsStale           => 1,
    };
}


### For convenience text output
my $statsKeyHeadings = [qw(
    Outlays Revenues MaxInvested Profit OverOut
    OverInvested Commiss RegFees OthFees NumTrades
)];
my $statsKeyHeadingsPattern = "%12s %12s %12s %12s %7s %12s %9s %7s %7s %9s";

my $statsKeys = [qw(
    totalOutlays              totalRevenues maxCashInvested profit    profitOverOutlays
    profitOverMaxCashInvested commissions   regulatoryFees  otherFees numberOfTrades
)];
my $statsKeysPattern = "%12.2f %12.2f %12.2f %12.2f %7.2f %12.2f %9.2f %7.2f %7.2f %9d";

my $statsLinesArray = [
        'First Trade Date'                  => 'startDate'                  => '%35s',
        'Last Trade Date'                   => 'endDate'                    => '%35s',
        'Maximum Cash Invested at Once'     => 'maxCashInvested'            => '%35.2f',
        'Sum Outlays'                       => 'totalOutlays'               => '%35.2f',
        'Sum Revenues'                      => 'totalRevenues'              => '%35.2f',
        'Total Profit'                      => 'profit'                     => '%35.2f',
        'Profit Over Years'                 => 'profitOverYears'            => '%35.2f',
        'Profit Over Sum Outlays'           => 'profitOverOutlays'          => '%35.2f',
        'Profit Over Max Cash Invested'     => 'profitOverMaxCashInvested'  => '%35.2f',
        'The Above (^) Over Years'          => 'pomciOverYears'             => '%35.2f',
        'Total Commissions'                 => 'commissions'                => '%35.2f',
        'Total Regulatory Fees'             => 'regulatoryFees'             => '%35.2f',
        'Total Other Fees'                  => 'otherFees'                  => '%35.2f',
        'Num Trades Included in Stats'      => 'numberOfTrades'             => '%35d',
        'Num Trades Excluded from Stats'    => 'numberExcluded'             => '%35d',
];


### Methods
sub stale {
    my ($self, $assertion) = @_;
    my $stats = $self->{stats};
    if (defined($assertion)) {
        if ($assertion == 1 or $assertion == 0) {
            if ($assertion) {
                my $value = 1;
                $stats->{stale}               = $value;
                $stats->{annualStatsStale}    = $value;
                $stats->{quarterlyStatsStale} = $value;
                $stats->{monthlyStatsStale}   = $value;
            }
            else {
                $stats->{stale} = 0;
            }
            return 1;
        }
        else {
            croak "Method 'stale' only accepts assertions in the form of 1 or 0 -- $assertion is not valid.";
        }
    }
    else {
        return $stats->{stale};
    }
}

sub allowZeroPrice {
    my ($self, $allowZeroPrice) = @_;
    if (defined($allowZeroPrice)) {
        $self->{allowZeroPrice} = $allowZeroPrice ? 1 : 0;
        return 1;
    }
    else {
        return $self->{allowZeroPrice};
    }
}

sub getSet {
    my ($self, $hashKey) = @_;
    if (exists($self->{sets}{$hashKey})) {
        return $self->{sets}{$hashKey};
    }
    else {
        return undef;
    }
}

sub getSetFiltered {
    my ($self, $hashKey) = @_;
    if ($self->{skipStocks}{$hashKey}) {
        return undef;
    }
    elsif (exists($self->{sets}{$hashKey})) {
        my $set = $self->{sets}{$hashKey};
        if ($set->stale()) {
            $set->accountSales();
        }
        if ($set->realizationCount() > 0) {
            return $set;
        }
        else {
            return undef;
        }
    }
    else {
        return undef;
    }
}

sub getFilteredSets {
    my $self = shift;
    my @sets;
    foreach my $hashKey (sort keys %{$self->{sets}}) {
        my $set = $self->getSetFiltered($hashKey);
        $set and push(@sets, $set);
    }
    return \@sets;
}

sub addToSet {
    my ($self, $at) = @_;
    if (ref($at) and ref($at) eq 'Finance::StockAccount::AccountTransaction') {
        my $hashKey = $at->hashKey();
        my $set = $self->getSet($hashKey);
        my $status;
        if ($set) {
            $status = $set->add([$at]);
        }
        else {
            $set = Finance::StockAccount::Set->new([$at]);
            $self->{sets}{$hashKey} = $set;
            $status = $set;
        }
        $status and $self->stale(1);
        return $status;
    }
    else {
        warn "Method addToSet requires a valid AccountTransaction object.\n";
        return 0;
    }
}

sub addAccountTransactions {
    my ($self, $accountTransactions) = @_;
    if (ref($accountTransactions) and ref($accountTransactions) eq 'ARRAY') {
        my $added = 0;
        foreach my $at (@$accountTransactions) {
            $self->addToSet($at) and $added++;
        }
        $added and $self->stale(1);
        return $added;
    }
    else {
        warn "Method addAccountTransactions requiers a reference to an array of AccountTransaction objects.\n";
        return 0;
    }
}

sub stockTransaction {
    my ($self, $init) = @_;
    my $helpString = q{  Please see 'perldoc Finance::StockAccount'.};
    if (!(exists($init->{tm}) or exists($init->{dateString}))) {
        carp "A date is required to add a stock transaction, using either the 'tm' key or the 'dateString' key.$helpString";
        return 0;
    }
    elsif (!(exists($init->{stock}) or exists($init->{symbol}))) {
        carp "A stock is required to add a transaction, using either the 'stock' key or the 'symbol' key.$helpString";
        return 0;
    }
    elsif (!(exists($init->{action}) and (grep { $_ eq $init->{action} } qw(buy sell short cover)))) {
        carp "To add a transaction, you must specify an action, one of 'buy', 'sell', 'short', or 'cover'.$helpString";
        return 0;
    }
    elsif (!(exists($init->{quantity}) and $init->{quantity} =~ /[0-9]/ and $init->{quantity} > 0)) {
        carp "To add a transaction, you must specify a numeric quantity, and it must be greater than zero.$helpString";
        return 0;
    }
    elsif (!(exists($init->{price}) and $init->{price} =~ /[0-9]/)) {
        carp "To add a transaction, you must specify a price, and it must be numeric.$helpString";
        return 0;
    }
    elsif ($init->{price} <= 0 and !$self->{allowZeroPrice}) {
        carp "To add a transaction, price must be greater than zero.  By default, prices zero or lower are treated as suspect and not included in calculations.\nYou may override this default behavior by setting 'allowZeroPrice' to true.$helpString";
        return 0;
    }
    else {
        if (exists($init->{stock}) and (exists($init->{symbol}) or exists($init->{exchange}))) {
            carp "To add a transaction, you may specify a Finance::StockAccount::Stock object, or a symbol (optionally with an exchange).\nYou need not specify both.  Proceeding on the assumption that the stock object is intentional and the symbol/exchange are accidental...";
            exists($init->{symbol}) and delete($init->{symbol});
            exists($init->{exchange}) and delete($init->{exchange});
        }
        my $at = Finance::StockAccount::AccountTransaction->new($init);
        if ($at) {
            return $self->addToSet($at);
        }
        else {
            carp "Unable to create AccountTransaction object with those parameters.\n";
            return 0;
        }
    }
}

sub skipStocks {
    my ($self, @skipStocks) = @_;
    my $count = 0;
    if (scalar(@skipStocks)) {
        foreach my $stock (@skipStocks) {
            $self->{skipStocks}{$stock} = 1;
        }
        $self->stale(1);
        return 1;
    }
    else {
        return sort keys %{$self->{skipStocks}};
    }
}

sub resetSkipStocks {
    my $self = shift;
    if (scalar(keys %{$self->{skipStocks}})) {
        $self->{skipStocks} = {};
        $self->stale(1);
    }
    return 1;
}

sub staleSets {
    my $self = shift;
    my $stale = 0;
    foreach my $hashKey (keys %{$self->{sets}}) {
        my $set = $self->getSet($hashKey);
        if ($set) {
            $stale += $set->stale();
        }
    }
    return $stale;
}

sub calculateMaxCashInvested {
    my ($self, $realizations) = @_;
    my @allTransactions = sort { $a->tm() <=> $b->tm() } map { @{$_->acquisitions()}, $_->divestment() } @$realizations;
    my $numberOfTrades = scalar(@allTransactions);
    @$realizations = ();
    my ($total, $max) = (0, 0);
    for (my $x=0; $x
        my $transaction = $allTransactions[$x];
        $total += 0 - $transaction->cashEffect();
        $total > $max and $max = $total;
    }
    @allTransactions = ();
    if (wantarray()) {
        return $max, $numberOfTrades;
    }
    else {
        return $max;
    }
}

sub calculateStats {
    my $self = shift;
    my ($totalOutlays, $totalRevenues, $profit, $commissions, $regulatoryFees, $otherFees, $numberExcluded, $transactionCount) = (0, 0, 0, 0, 0, 0, 0, 0);
    my ($startDate, $endDate);
    my $setCount = 0;
    my @allRealizations = ();
    my $stats = $self->getNewStatsHash();
    $self->{stats} = $stats;
    $self->stale(0);
    foreach my $hashKey (keys %{$self->{sets}}) {
        my $set = $self->getSetFiltered($hashKey);
        if ($set) {
            if ($set->stale()) {
                $set->accountSales();
            }
            $numberExcluded += $set->unrealizedTransactionCount();
            next unless $set->success();

            ### Simple Totals
            $totalOutlays       += $set->totalOutlays();
            $totalRevenues      += $set->totalRevenues();
            $profit             += $set->profit();
            $commissions        += $set->commissions();
            $regulatoryFees     += $set->regulatoryFees();
            $otherFees          += $set->otherFees();
            $transactionCount   += $set->transactionCount();

            ### Date-Aware Totals
            push(@allRealizations, @{$set->realizations()});

            ### End-Date, Start-Date
            my $setStart = $set->startDate();
            $setStart or die "Didn't get set startDate for hashkey $hashKey\n";
            if (!defined($startDate)) {
                $startDate = $setStart;
            }
            elsif ($setStart < $startDate) {
                $startDate = $setStart;
            }
            my $setEnd   = $set->endDate();
            if (!$endDate) {
                $endDate = $setEnd;
            }
            elsif ($setEnd > $endDate) {
                $endDate = $setEnd;
            }
            $setCount++;
        }
        else {
            my $unfilteredSet = $self->getSet($hashKey);
            $numberExcluded += $unfilteredSet->unrealizedTransactionCount();
            if ($self->{skipStocks}{$hashKey}) {
                $numberExcluded += $unfilteredSet->transactionCount();
            }
        }
    }
    $stats->{numberExcluded} = $numberExcluded;
    if ($setCount > 0) {
        if ($totalOutlays) {
            my $profitOverOutlays = $profit / $totalOutlays;
            $stats->{totalOutlays}      = $totalOutlays;
            $stats->{totalRevenues}     = $totalRevenues;
            $stats->{profit}            = $profit;
            $stats->{commissions}       = $commissions;
            $stats->{regulatoryFees}    = $regulatoryFees;
            $stats->{otherFees}         = $otherFees;
            $stats->{profitOverOutlays} = $profitOverOutlays;
            $stats->{startDate}         = $startDate;
            $stats->{endDate}           = $endDate;
            my $secondsInYear = 60 * 60 * 24 * 365.25;
            my $secondsInAccount = $endDate->epoch() - $startDate->epoch();
            if (!$secondsInAccount) {
                croak "No time passed in account? Can't calculate time-related stats.";
            }
            my $annualRatio                     = $secondsInYear / $secondsInAccount;
            $stats->{annualRatio}               = $annualRatio;
            $stats->{profitOverYears}           = $profit * $annualRatio;
            my $maxCashInvested = $self->calculateMaxCashInvested(\@allRealizations);
            $stats->{maxCashInvested}           = $maxCashInvested;
            $stats->{profitOverOutlays}         = $profit / $totalOutlays;
            my $pomci                           = $profit / $maxCashInvested;
            $stats->{profitOverMaxCashInvested} = $pomci;
            $stats->{pomciOverYears}            = $pomci * $annualRatio;
            $stats->{numberOfTrades}            = $transactionCount;
            return 1;
        }
        else {
            carp "No totalOutlays found on which to compute stats.\n";
            return 0;
        }
    }
    else {
        carp "No realized gains in stock account.\n";
        return 0;
    }
}

sub getStats {
    my $self = shift;
    if ($self->{stats}{stale} or $self->staleSets()) {
        return $self->calculateStats();
    }
    else {
        return 1;
    }
}

sub stats {
    my $self = shift;
    $self->getStats();
    my $stats = $self->{stats};
    my @stats;
    for (my $x=0; $x
        my $key = $statsLinesArray->[$x+1];
        push(@stats, $key, $stats->{$key});
    }
    return \@stats;
}

sub statsString {
    my $self = shift;
    $self->getStats();
    my $stats = $self->{stats};
    my $statsString;
    for (my $x=0; $x
        my ($name, $key, $valPattern) = @$statsLinesArray[$x .. $x+2];
        $statsString .= sprintf("%30s $valPattern\n", $name, $stats->{$key});
    }
    return $statsString;
}

sub availableAcquisitionsString {
    my ($self, $inputKey) = @_;
    my ($string, @hashKeys);
    if ($inputKey) {
        @hashKeys = ($inputKey);
    }
    else {
        @hashKeys = keys %{$self->{sets}};
    }
    foreach my $hashKey (@hashKeys) {
        my $set = $self->getSet($hashKey);
        if ($set) {
            $string .= $set->availableAcquisitionsString();
        }
    }
    return $string;
}

sub statsForPeriod {
    my ($self, $tm1, $tm2) = @_;
    my ($totalOutlays, $totalRevenues, $profit, $commissions, $regulatoryFees, $otherFees, $transactionCount) = (0, 0, 0, 0, 0, 0, 0);
    my @allRealizations = ();
    my $setCount = 0;
    foreach my $hashKey (keys %{$self->{sets}}) {
        my $unfilteredSet = $self->getSet($hashKey);
        $unfilteredSet->setDateLimit($tm1, $tm2);
        my $set = $self->getSetFiltered($hashKey);
        if ($set) {
            $setCount++;
            $totalOutlays       += $set->totalOutlays();
            $totalRevenues      += $set->totalRevenues();
            $profit             += $set->profit();
            $commissions        += $set->commissions();
            $regulatoryFees     += $set->regulatoryFees();
            $otherFees          += $set->otherFees();
            $transactionCount   += $set->transactionCount();
            push(@allRealizations, @{$set->realizations()});
        }
        $unfilteredSet->clearDateLimit();
    }
    if ($setCount > 0 and $totalOutlays) {
        my $maxCashInvested = $self->calculateMaxCashInvested(\@allRealizations);
        return {
            totalOutlays                => $totalOutlays,
            totalRevenues               => $totalRevenues,
            maxCashInvested             => $maxCashInvested,
            profit                      => $profit,
            profitOverOutlays           => $profit / $totalOutlays,
            profitOverMaxCashInvested   => $profit / $maxCashInvested,
            commissions                 => $commissions,
            regulatoryFees              => $regulatoryFees,
            otherFees                   => $otherFees,
            numberOfTrades              => $transactionCount,
        };
    }
    else {
        carp "I couldn't calculate stats for the period from $tm1 to $tm2 for this stock account.\n";
        return undef;
    }
}

sub calculateAnnualStats {
    my $self = shift;
    $self->getStats();
    my $stats       = $self->{stats};
    my $startDate   = $stats->{startDate};
    my $endDate     = $stats->{endDate};
    my $offset      = $startDate->offset();
    my $annualStats = [];
    foreach my $year ($startDate->year() .. $endDate->year()) {
        my $yearStart = Time::Moment->new(
            year       => $year,
            month      => 1,
            day        => 1,
            hour       => 0,
            minute     => 0,
            second     => 01,
            nanosecond => 0,
            offset     => $offset,
        );
        my $yearEnd   = Time::Moment->new(
            year       => $year,
            month      => 12,
            day        => 31,
            hour       => 23,
            minute     => 59,
            second     => 59,
            nanosecond => 0,
            offset     => $offset,
        );
        my $yearStats = $self->statsForPeriod($yearStart, $yearEnd);
        $yearStats->{year} = $year;
        push(@$annualStats, $yearStats);
    }
    $stats->{annualStats} = $annualStats;
    $stats->{annualStatsStale} = 0;
    return $annualStats;
}

sub calculateQuarterlyStats {
    my $self = shift;
    $self->getStats();
    my $quarterlyStats = [];
    my $stats       = $self->{stats};
    my $startDate   = $stats->{startDate};
    my $endDate     = $stats->{endDate};
    my $offset      = $startDate->offset();
    my $startYear   = $startDate->year();
    my $startQuarter  = ceil($startDate->month()/3);
    my $currDate = Time::Moment->new(
        year       => $startYear,
        month      => ($startQuarter - 1) * 3 + 1,
        day        => 1,
        hour       => 0,
        minute     => 0,
        second     => 01,
        nanosecond => 0,
        offset     => $offset,
    );
    while ($currDate < $endDate) {
        my $quarterEnd   = $currDate->plus_months(3);
        my $quarterStats = $self->statsForPeriod($currDate, $quarterEnd);
        $quarterStats->{year}    = $currDate->year();
        $quarterStats->{quarter} = ceil($currDate->month()/3);
        push(@$quarterlyStats, $quarterStats);
        $currDate = $quarterEnd;
    }
    $stats->{quarterlyStats} = $quarterlyStats;
    $stats->{quarterlyStatsStale} = 0;
    return $quarterlyStats;
}

sub calculateMonthlyStats {
    my $self = shift;
    $self->getStats();
    my $monthlyStats = [];
    my $stats       = $self->{stats};
    my $startDate   = $stats->{startDate};
    my $endDate     = $stats->{endDate};
    my $offset      = $startDate->offset();
    my $startYear   = $startDate->year();
    my $startMonth  = $startDate->month();
    my $currDate = Time::Moment->new(
        year       => $startYear,
        month      => $startMonth,
        day        => 1,
        hour       => 0,
        minute     => 0,
        second     => 01,
        nanosecond => 0,
        offset     => $offset,
    );
    while ($currDate < $endDate) {
        my $monthEnd   = $currDate->plus_months(1);
        my $monthStats = $self->statsForPeriod($currDate, $monthEnd);
        $monthStats->{year}    = $currDate->year();
        $monthStats->{month} = $currDate->month();
        push(@$monthlyStats, $monthStats);
        $currDate = $monthEnd;
    }
    $stats->{monthlyStats} = $monthlyStats;
    $stats->{monthlyStatsStale} = 0;
    return $monthlyStats;
}

sub annualStats {
    my $self = shift;
    my $stats = $self->{stats};
    if ($stats->{annualStatsStale}) {
        return $self->calculateAnnualStats();
    }
    else {
        return $stats->{annualStats};
    }
}

sub quarterlyStats {
    my $self = shift;
    my $stats = $self->{stats};
    if ($stats->{quarterlyStatsStale}) {
        return $self->calculateQuarterlyStats();
    }
    else {
        return $stats->{quarterlyStats};
    }
}

sub monthlyStats {
    my $self = shift;
    my $stats = $self->{stats};
    if ($stats->{monthlyStatsStale}) {
        return $self->calculateMonthlyStats();
    }
    else {
        return $stats->{monthlyStats};
    }
}

sub periodicStatsString {
    my ($self, $params) = @_;
    my $periodHeadings          = $params->{periodHeadings};
    my $periodHeadingsPattern   = $params->{periodHeadingsPattern};
    my $periodKeys              = $params->{periodKeys};
    my $periodValuesPattern     = $params->{periodValuesPattern};
    my $periodHeadingsWidth     = $params->{periodHeadingsWidth};
    my $statsArray              = $params->{statsArray};
    my $statsString = sprintf("$periodHeadingsPattern $statsKeyHeadingsPattern\n", @$periodHeadings, @$statsKeyHeadings);
    my $lineLength = length($statsString);
    my $pattern = "$periodValuesPattern $statsKeysPattern\n";
    my $totals;
    my $verbose = $self->{verbose};
    if ($verbose) {
        $totals = [map { 0 } (0 .. scalar(@$statsKeys) - 1)];
    }
    foreach my $period (@$statsArray) {
        my @row = map { $period->{$_} } @$periodKeys;
        for (my $x=0; $x
            my $key = $statsKeys->[$x];
            my $value = $period->{$key};
            if ($verbose) {
                $totals->[$x] += $value;
            }
            push(@row, $value);
        }
        $statsString .= sprintf($pattern, @row);
    }
    if ($verbose) {
        $statsString .= '-'x$lineLength . "\n"
            . sprintf("%-${periodHeadingsWidth}s $statsKeysPattern\n", 'COL SUMS', @$totals);
    }
    $statsString .= '-'x$lineLength . "\n"
        . sprintf("%-${periodHeadingsWidth}s $statsKeysPattern\n", 'ACCT TOTAL', map { $self->{stats}{$_} } @$statsKeys);
    return $statsString;
}

sub annualStatsString {
    my $self = shift;
    return $self->periodicStatsString({
        periodHeadings          => [qw(Year)],
        periodHeadingsPattern   => "%10s",
        periodKeys              => [qw(year)],
        periodValuesPattern     => "%10d",
        periodHeadingsWidth     => 10,
        statsArray              => $self->annualStats(),
    });
}

sub quarterlyStatsString {
    my $self = shift;
    return $self->periodicStatsString({
        periodHeadings          => [qw(Year Quarter)],
        periodHeadingsPattern   => "%4s %7s",
        periodKeys              => [qw(year quarter)],
        periodValuesPattern     => "%4d %7d",
        periodHeadingsWidth     => 12,
        statsArray              => $self->quarterlyStats(),
    });
}

sub monthlyStatsString {
    my $self = shift;
    return $self->periodicStatsString({
        periodHeadings          => [qw(Year Month)],
        periodHeadingsPattern   => "%4s %5s",
        periodKeys              => [qw(year month)],
        periodValuesPattern     => "%4d %5d",
        periodHeadingsWidth     => 10,
        statsArray              => $self->monthlyStats(),
    });
}

sub profit {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{profit};
}

sub maxCashInvested {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{maxCashInvested};
}

sub profitOverOutlays {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{profitOverOutlays};
}

sub profitOverMaxCashInvested {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{profitOverMaxCashInvested};
}

sub profitOverYears {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{profitOverYears};
}

sub profitOverMaxCashInvestedOverYears {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{pomciOverYears};
}

sub commissions {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{commissions};
}

sub totalCommissions {
    return shift->commissions();
}

sub regulatoryFees {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{regulatoryFees};
}

sub otherFees {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{otherFees};
}

sub numberOfTrades {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{numberOfTrades};
}

sub numberExcluded {
    my $self = shift;
    $self->getStats();
    return $self->{stats}{numberExcluded};
}

sub totalFees {
    my $self = shift;
    return $self->regulatoryFees() + $self->otherFees();
}

sub summaryByStock {
    my $self = shift;
    my $spacer = Finance::StockAccount::Set->oneLinerSpacer();
    my $string = $spacer . Finance::StockAccount::Set->oneLinerHeader() . $spacer;
    my $sets = $self->getFilteredSets();
    foreach my $set (@$sets) {
        $string .= $set->oneLiner() . $spacer;
    }
    return $string;
}


sub realizationsString {
    my $self = shift;
    my $string = Finance::StockAccount::Realization->headerString();
    my $sets = $self->getFilteredSets();
    foreach my $set (@$sets) {
        $string .= $set->realizationsString();
    }
    return $string;
}


1;

__END__