Rozšírenie enginu

Analytics a kalkulátory v RoundlyConsulting\TradingAnalytics\Analytics\* sú navrhnuté na rozširovanie — v podtriede Analytics zaregistrujete vlastné kalkulátory a fasáde poviete, aby ju vytvárala, cez TradingAnalytics::using() (pozrite Vlastné kalkulátory nižšie), alebo pre konkrétnu inštanciu nahradíte háčiky pre každý obchod a po prechode:

$analytics = TradingAnalytics::for($trades)
    ->onEachTrade(function (Analytics $analytics, string $calculator, Trade $trade) {
        // observe, skip or adjust the trade for this calculator, then run it
        $calculator::calculatePerTrade($analytics, $trade);
    })
    ->afterTrades(function (Analytics $analytics, string $calculator) {
        $calculator::calculateAfterTrades($analytics);
    })
    ->calculate();

Háčiky nahrádzajú predvolený krok

Háčik sa volá raz za každý kalkulátor pre každý obchod (onEachTrade) alebo raz za každý kalkulátor po prechode (afterTrades) — namiesto vlastného kroku kalkulátora. Ak chcete zachovať predvolené hodnoty, zavolajte krok sami; ak ho vynecháte, metriky zostanú na nule. Pozorovanie so zachovaným výpočtom:

use RoundlyConsulting\TradingAnalytics\Analytics\Counts;

// Observe the trades one calculator sees, and keep every default figure
$seen = 0;

$analytics = TradingAnalytics::for($trades)
    ->onEachTrade(function (Analytics $analytics, string $calculator, Trade $trade) use (&$seen): void {
        if ($calculator === Counts::class) {
            $seen++;                                          // observe
        }

        $calculator::calculatePerTrade($analytics, $trade);   // keep the default step
    })
    ->calculate();

$seen; // 3 — one call per trade for each calculator

Vlastné kalkulátory

Kalkulátor implementuje AnalyticsInterface: statickú calculatePerTrade(Analytics, Trade), volanú pre každý obchod, a statickú calculateAfterTrades(Analytics), volanú raz po prechode. Zaregistrujete ho podtriedou Analytics a uvedením v $defaultCalculators; prípadné závislosti deklarujte v $dependencies. Zachovajte signatúru konštruktora, aby make() a for() naďalej vracali vašu podtriedu, a fasáde povedzte, aby ju vytvárala, cez TradingAnalytics::using() — raz, napríklad v boot() service providera, keďže manažér je singleton:

use RoundlyConsulting\TradingAnalytics\Analytics;
use RoundlyConsulting\TradingAnalytics\DataTransferObjects\Trade;
use RoundlyConsulting\TradingAnalytics\Interfaces\AnalyticsInterface;

final class LongestHold implements AnalyticsInterface
{
    public static function calculatePerTrade(Analytics $analytics, Trade $trade): void
    {
        if (! $analytics instanceof DeskAnalytics || $trade->isOpen()) {
            return;
        }

        $seconds = (int) $trade->openTime->diffInSeconds($trade->closeTime);

        $analytics->longestHoldSeconds = max($analytics->longestHoldSeconds, $seconds);
    }

    public static function calculateAfterTrades(Analytics $analytics): void
    {
        //
    }
}

final class DeskAnalytics extends Analytics
{
    public int $longestHoldSeconds = 0;

    protected array $defaultCalculators = [
        Analytics\Counts::class,
        Analytics\RealizedGrossProfitAndLoss::class,
        Analytics\RealizedNetProfitAndLoss::class,
        Analytics\Wins::class,
        LongestHold::class,
    ];

    public function toArray(): array
    {
        return [
            ...parent::toArray(),
            'longest_hold_seconds' => $this->longestHoldSeconds,
        ];
    }
}

// Once, e.g. in a service provider's boot() — the manager is a singleton
TradingAnalytics::using(DeskAnalytics::class);

$desk = TradingAnalytics::calculate($trades);      // a DeskAnalytics instance
$desk->longestHoldSeconds;                         // 86400
array_keys($desk->toArray());
// ['counts', 'wins', 'profit_and_loss', 'longest_hold_seconds']

using() vyhodí InvalidEngineException pre triedu, ktorá nie je Analytics ani jej podtrieda. Vlastné kalkulátory prijímajú only() aj except() a vypíše ich metrics().

SequentialAnalyticsInterface — značka pre kalkulátory, ktorých výsledky sledujú poradie zatvárania obchodov, ako MaxDrawdown, Streaks a kumulatívne výnosy. Kým niektorý z nich beží, engine odmietne realizované obchody mimo poradia podľa času zatvorenia (pozrite Poradie obchodov).
MultiPassAnalyticsInterface — značka, ktorú nesie RiskAdjustedReturns: počas prechodu priebežne zbiera hodnoty a výsledky odvodí v calculateAfterTrades().

Pomocníci BcMath

RoundlyConsulting\TradingAnalytics\Support\BcMath dopĺňa odmocniny, ktoré bcmath nemá, vypočítané bez floatov:

use RoundlyConsulting\TradingAnalytics\Support\BcMath;

BcMath::sqrt('2', 10);         // '1.4142135623'
BcMath::nthRoot('27', 3, 10);  // '3.0000000000' — Newton's method, no floats

Prejavte lásku k open source

Tento balík je zadarmo pod licenciou MIT. Ak vám šetrí čas, jednorazový príspevok alebo členstvo na Patreone nám pomôže ho ďalej udržiavať, testovať a dokumentovať.

Ďalšie spôsoby podpory vrátane kryptomien

Odoslaním daru súhlasíte s našimi podmienkami prijímania darov.

Podporte našu open-source prácu Pridajte sa k nám na Patreone

Chcete to zabudovať do svojho produktu?

Naše balíky integrujeme do zákazkových Laravel a AI riešení. Napíšte nám, na čom pracujete, a ozveme sa do 48 hodín.

Ponuka do 48 hodín Prezrieť všetky balíky