FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// src/screens/ai_quant_lab/QuantModulePanel_AdvancedDisplays_Factors.cpp
//
// ADVANCED-category renderers for factor + strategy analytics:
// factor_evaluation (IC / evaluation report / risk metrics / factor returns)
// and strategy_builder (create_*, portfolio_metrics).
//
// Part of the partial-class split of QuantModulePanel_AdvancedDisplays.cpp.
#include "screens/ai_quant_lab/QuantModulePanel.h"
#include "screens/ai_quant_lab/QuantModulePanel_AdvancedHelpers.h"
#include "screens/ai_quant_lab/QuantModulePanel_Common.h"
#include "screens/ai_quant_lab/QuantModulePanel_GsHelpers.h"
#include "screens/ai_quant_lab/QuantModulePanel_Styles.h"
#include "ui/theme/Theme.h"
#include <QAbstractItemView>
#include <QColor>
#include <QFileInfo>
#include <QHBoxLayout>
#include <QHash>
#include <QHeaderView>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonValue>
#include <QLabel>
#include <QList>
#include <QPair>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QVBoxLayout>
#include <QWidget>
#include <algorithm>
#include <cmath>
#include <functional>
#include <limits>
namespace fincept::screens {
using namespace fincept::services::quant;
using namespace fincept::screens::quant_styles;
using namespace fincept::screens::quant_common;
using namespace fincept::screens::quant_gs_helpers;
using namespace fincept::screens::quant_advanced_helpers;
void QuantModulePanel::display_factor_evaluation_result(const QString& command, const QJsonObject& payload) {
clear_results();
if (!check_success(payload, [this](const QString& s) { display_error(s); }))
return;
const QString accent = module_.color.name();
QString header_text = command.toUpper();
header_text.replace('_', ' ');
results_layout_->addWidget(gs_section_header(header_text, accent));
if (command == "check_status") {
const bool pd = payload.value("pandas_available").toBool();
const bool ql = payload.value("qlib_available").toBool();
QList<QWidget*> top = {
gs_make_card(tr("PANDAS"), pd ? tr("AVAILABLE") : tr("MISSING"), this,
pd ? ui::colors::POSITIVE() : ui::colors::NEGATIVE()),
gs_make_card(tr("QLIB"), ql ? tr("AVAILABLE") : tr("MISSING"), this,
ql ? ui::colors::POSITIVE() : ui::colors::NEGATIVE()),
};
results_layout_->addWidget(gs_card_row(top, this));
status_label_->setText(tr("Factor evaluation ready"));
return;
}
// ── calculate_ic ─────────────────────────────────────────────────────────
if (command == "calculate_ic") {
const double ic_mean = payload.value("IC_mean").toDouble();
const double ic_std = payload.value("IC_std").toDouble();
const double icir = payload.value("ICIR").toDouble();
const double ic_pos = payload.value("IC_positive_rate").toDouble();
const double pval = payload.value("p_value").toDouble();
const bool sig = payload.value("is_significant").toBool();
// Flat prediction / return lists give one full-sample IC; the dispersion statistics need a
// rolling-IC series (>= 2 windows). Show a dash rather than the zeros the script fills in.
const bool rolling = payload.value("rolling_ic_available").toBool(true);
const QString dash = QString::fromUtf8("—");
QList<QWidget*> top = {
gs_make_card(rolling ? tr("IC MEAN") : tr("IC (FULL SAMPLE)"), QString::number(ic_mean, 'f', 4), this,
gs_pos_neg_color(ic_mean)),
gs_make_card(tr("IC STD"), rolling ? QString::number(ic_std, 'f', 4) : dash, this),
gs_make_card(tr("ICIR"), rolling ? QString::number(icir, 'f', 3) : dash, this,
!rolling ? ui::colors::TEXT_PRIMARY()
: icir >= 0.5 ? ui::colors::POSITIVE()
: icir > 0 ? ui::colors::WARNING()
: ui::colors::NEGATIVE()),
gs_make_card(tr("POS RATE"), rolling ? QString::number(ic_pos * 100, 'f', 1) + "%" : dash, this,
ic_pos > 0.55 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
};
results_layout_->addWidget(gs_card_row(top, this));
QList<QWidget*> stats = {
gs_make_card(tr("IC MAX"), rolling ? QString::number(payload.value("IC_max").toDouble(), 'f', 4) : dash,
this, ui::colors::POSITIVE()),
gs_make_card(tr("IC MIN"), rolling ? QString::number(payload.value("IC_min").toDouble(), 'f', 4) : dash,
this, ui::colors::NEGATIVE()),
gs_make_card(tr("IC MEDIAN"),
rolling ? QString::number(payload.value("IC_median").toDouble(), 'f', 4) : dash, this),
gs_make_card(tr("OBSERVATIONS"), QString::number(payload.value("observations").toInt()), this),
};
results_layout_->addWidget(gs_card_row(stats, this));
QList<QWidget*> moments = {
gs_make_card(tr("SKEWNESS"), rolling ? QString::number(payload.value("IC_skewness").toDouble(), 'f', 4) : dash,
this),
gs_make_card(tr("KURTOSIS"), rolling ? QString::number(payload.value("IC_kurtosis").toDouble(), 'f', 4) : dash,
this),
gs_make_card(tr("p-VALUE"), QString::number(pval, 'f', 4), this,
pval < 0.05 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
gs_make_card(tr("SIGNIFICANT"), sig ? tr("YES") : tr("NO"), this,
sig ? ui::colors::POSITIVE() : ui::colors::NEGATIVE()),
};
results_layout_->addWidget(gs_card_row(moments, this));
const QString ic_note = payload.value("note").toString();
if (!ic_note.isEmpty()) {
auto* note = gs_section_header(ic_note, accent);
note->setWordWrap(true);
results_layout_->addWidget(note);
}
// Sample IC series
const auto series = payload.value("ic_series").toArray();
if (!series.isEmpty()) {
const int rows = std::min<int>(15, series.size());
const int step = std::max<int>(1, series.size() / rows);
auto* table = new QTableWidget(rows, 2, this);
table->setHorizontalHeaderLabels({tr("Date"), tr("IC")});
table->verticalHeader()->setVisible(false);
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
table->setStyleSheet(table_ss());
table->setMaximumHeight(rows * 22 + 32);
for (int i = 0, r = 0; i < series.size() && r < rows; i += step, ++r) {
const auto o = series[i].toObject();
table->setItem(r, 0, new QTableWidgetItem(o.value("date").toString()));
const double ic = o.value("ic").toDouble();
auto* it = new QTableWidgetItem(QString::number(ic, 'f', 4));
it->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
it->setForeground(QColor(gs_pos_neg_color(ic)));
table->setItem(r, 1, it);
table->setRowHeight(r, 22);
}
results_layout_->addWidget(table);
}
status_label_->setText(
tr("IC=%1 ICIR=%2 p=%3").arg(ic_mean, 0, 'f', 4).arg(icir, 0, 'f', 3).arg(pval, 0, 'f', 4));
return;
}
// ── analyze_factor_returns ───────────────────────────────────────────────
if (command == "analyze_factor_returns") {
const double ls_sharpe = payload.value("long_short_sharpe").toDouble();
const double ls_ret = payload.value("long_short_mean_return").toDouble();
const double mono = payload.value("monotonicity").toDouble();
const double spread = payload.value("spread").toDouble();
QList<QWidget*> top = {
gs_make_card(tr("L/S SHARPE"), QString::number(ls_sharpe, 'f', 3), this,
ls_sharpe >= 1.0 ? ui::colors::POSITIVE()
: ls_sharpe > 0 ? ui::colors::WARNING()
: ui::colors::NEGATIVE()),
gs_make_card(tr("L/S MEAN RET"), fmt_pct_safe(QJsonValue(ls_ret), 4), this, gs_pos_neg_color(ls_ret)),
gs_make_card(tr("SPREAD"), fmt_pct_safe(QJsonValue(spread), 4), this, gs_pos_neg_color(spread)),
gs_make_card(tr("MONOTONICITY"), QString::number(mono * 100, 'f', 1) + "%", this,
mono >= 0.7 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
};
results_layout_->addWidget(gs_card_row(top, this));
const auto qs = payload.value("quantile_stats").toObject();
if (!qs.isEmpty()) {
QList<QPair<QString, QJsonObject>> rows;
for (auto it = qs.begin(); it != qs.end(); ++it)
rows.append({it.key(), it.value().toObject()});
std::sort(rows.begin(), rows.end(), [](const auto& a, const auto& b) { return a.first < b.first; });
auto* table = new QTableWidget(rows.size(), 5, this);
table->setHorizontalHeaderLabels(
{tr("Quantile"), tr("Mean Return"), tr("Std"), tr("Sharpe"), tr("Win Rate")});
table->verticalHeader()->setVisible(false);
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
table->setStyleSheet(table_ss());
table->setMaximumHeight(qMin(rows.size() * 26 + 32, 280));
for (int r = 0; r < rows.size(); ++r) {
const auto& q = rows[r].second;
table->setItem(r, 0, new QTableWidgetItem(rows[r].first));
const double mr = q.value("mean_return").toDouble();
auto* mri = new QTableWidgetItem(QString::number(mr * 100, 'f', 4) + "%");
mri->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
mri->setForeground(QColor(gs_pos_neg_color(mr)));
table->setItem(r, 1, mri);
auto* sd = new QTableWidgetItem(QString::number(q.value("std_return").toDouble() * 100, 'f', 4) + "%");
sd->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
table->setItem(r, 2, sd);
const double sh = q.value("sharpe").toDouble();
auto* shi = new QTableWidgetItem(QString::number(sh, 'f', 3));
shi->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
shi->setForeground(QColor(gs_pos_neg_color(sh)));
table->setItem(r, 3, shi);
auto* wi = new QTableWidgetItem(QString::number(q.value("win_rate").toDouble() * 100, 'f', 1) + "%");
wi->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
table->setItem(r, 4, wi);
table->setRowHeight(r, 26);
}
results_layout_->addWidget(table);
}
status_label_->setText(tr("L/S Sharpe=%1 spread=%2%").arg(ls_sharpe, 0, 'f', 3).arg(spread * 100, 0, 'f', 4));
return;
}
// ── calculate_risk_metrics ───────────────────────────────────────────────
if (command == "calculate_risk_metrics") {
const double vol = payload.value("volatility").toDouble();
const double mdd = payload.value("max_drawdown").toDouble();
const double beta = payload.value("beta").toDouble();
const double te = payload.value("tracking_error").toDouble();
QList<QWidget*> top = {
gs_make_card(tr("VOLATILITY"), fmt_pct_safe(QJsonValue(vol)), this),
gs_make_card(tr("MAX DRAWDOWN"), fmt_pct_safe(QJsonValue(mdd)), this,
mdd <= -0.20 ? ui::colors::NEGATIVE() : ui::colors::WARNING()),
gs_make_card(tr("BETA"), QString::number(beta, 'f', 3), this,
beta > 1.2 ? ui::colors::WARNING() : ui::colors::TEXT_PRIMARY()),
gs_make_card(tr("TRACKING ERROR"), fmt_pct_safe(QJsonValue(te)), this),
};
results_layout_->addWidget(gs_card_row(top, this));
QList<QWidget*> tail = {
gs_make_card(tr("DOWNSIDE DEV"), fmt_pct_safe(payload.value("downside_deviation")), this,
ui::colors::WARNING()),
gs_make_card(tr("VaR 95%"), fmt_pct_safe(payload.value("var_95")), this, ui::colors::WARNING()),
gs_make_card(tr("CVaR 95%"), fmt_pct_safe(payload.value("cvar_95")), this, ui::colors::NEGATIVE()),
gs_make_card(tr("DD DURATION"), tr("%1 days").arg(payload.value("max_drawdown_duration").toInt()), this),
};
results_layout_->addWidget(gs_card_row(tail, this));
QList<QWidget*> capture = {
gs_make_card(tr("UP CAPTURE"), QString::number(payload.value("up_capture").toDouble() * 100, 'f', 1) + "%",
this,
payload.value("up_capture").toDouble() > 1.0 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
gs_make_card(
tr("DOWN CAPTURE"), QString::number(payload.value("down_capture").toDouble() * 100, 'f', 1) + "%", this,
payload.value("down_capture").toDouble() < 1.0 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
gs_make_card(tr("SKEWNESS"), QString::number(payload.value("skewness").toDouble(), 'f', 3), this,
gs_pos_neg_color(payload.value("skewness").toDouble())),
gs_make_card(tr("KURTOSIS"), QString::number(payload.value("kurtosis").toDouble(), 'f', 3), this),
};
results_layout_->addWidget(gs_card_row(capture, this));
status_label_->setText(
tr("Vol=%1% MaxDD=%2% β=%3").arg(vol * 100, 0, 'f', 2).arg(mdd * 100, 0, 'f', 2).arg(beta, 0, 'f', 3));
return;
}
// ── generate_evaluation_report ───────────────────────────────────────────
if (command == "generate_evaluation_report") {
const auto rep = payload.value("report").toObject();
const QString rating = rep.value("rating").toString();
const double score = rep.value("overall_score").toDouble();
const auto ic = rep.value("ic_analysis").toObject();
const auto qa = rep.value("quantile_analysis").toObject();
const auto turn = rep.value("turnover_analysis").toObject();
QList<QWidget*> top = {
gs_make_card(tr("FACTOR"), rep.value("factor_name").toString(), this),
gs_make_card(tr("OVERALL SCORE"), QString::number(score, 'f', 1) + tr(" / 100"), this,
score >= 70 ? ui::colors::POSITIVE()
: score >= 40 ? ui::colors::WARNING()
: ui::colors::NEGATIVE()),
gs_make_card(tr("RATING"), rating.toUpper(), this, verdict_color_for(rating)),
gs_make_card(tr("PERIODS"), QString::number(rep.value("data_range").toObject().value("periods").toInt()),
this),
};
results_layout_->addWidget(gs_card_row(top, this));
results_layout_->addWidget(gs_section_header(tr("IC ANALYSIS"), accent));
QList<QWidget*> ic_cards = {
gs_make_card(tr("IC MEAN"), QString::number(ic.value("IC_mean").toDouble(), 'f', 4), this,
gs_pos_neg_color(ic.value("IC_mean").toDouble())),
gs_make_card(tr("ICIR"), QString::number(ic.value("ICIR").toDouble(), 'f', 3), this,
ic.value("ICIR").toDouble() >= 0.5 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
gs_make_card(tr("POS RATE"), QString::number(ic.value("IC_positive_rate").toDouble() * 100, 'f', 1) + "%",
this),
gs_make_card(tr("p-VALUE"), QString::number(ic.value("p_value").toDouble(), 'f', 4), this,
ic.value("p_value").toDouble() < 0.05 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
};
results_layout_->addWidget(gs_card_row(ic_cards, this));
results_layout_->addWidget(gs_section_header(tr("QUANTILE ANALYSIS"), accent));
if (!qa.value("success").toBool(true)) {
auto* note = gs_section_header(qa.value("error").toString(tr("Quantile analysis unavailable")),
ui::colors::WARNING());
note->setWordWrap(true);
results_layout_->addWidget(note);
} else {
QList<QWidget*> qa_cards = {
gs_make_card(tr("L/S SHARPE"), QString::number(qa.value("long_short_sharpe").toDouble(), 'f', 3), this,
qa.value("long_short_sharpe").toDouble() >= 1.0 ? ui::colors::POSITIVE()
: ui::colors::WARNING()),
gs_make_card(tr("SPREAD"), fmt_pct_safe(qa.value("spread"), 4), this,
gs_pos_neg_color(qa.value("spread").toDouble())),
gs_make_card(tr("MONOTONICITY"),
QString::number(qa.value("monotonicity").toDouble() * 100, 'f', 1) + "%", this,
qa.value("monotonicity").toDouble() >= 0.7 ? ui::colors::POSITIVE()
: ui::colors::WARNING()),
gs_make_card(tr("L/S MEAN RET"), fmt_pct_safe(qa.value("long_short_mean_return"), 4), this,
gs_pos_neg_color(qa.value("long_short_mean_return").toDouble())),
};
results_layout_->addWidget(gs_card_row(qa_cards, this));
}
if (!turn.isEmpty()) {
results_layout_->addWidget(gs_section_header(tr("TURNOVER"), accent));
QList<QWidget*> tu_cards = {
gs_make_card(tr("MEAN"), fmt_pct_safe(turn.value("mean_turnover")), this),
gs_make_card(tr("MEDIAN"), fmt_pct_safe(turn.value("median_turnover")), this),
gs_make_card(tr("MAX"), fmt_pct_safe(turn.value("max_turnover")), this, ui::colors::WARNING()),
gs_make_card(tr("OBS"), QString::number(turn.value("observations").toInt()), this),
};
results_layout_->addWidget(gs_card_row(tu_cards, this));
}
status_label_->setText(
tr("%1: %2/100 (%3)").arg(rep.value("factor_name").toString()).arg(score, 0, 'f', 1).arg(rating));
return;
}
display_result(payload);
}
// ═════════════════════════════════════════════════════════════════════════════
// 7. STRATEGY BUILDER
// ═════════════════════════════════════════════════════════════════════════════
void QuantModulePanel::display_strategy_builder_result(const QString& command, const QJsonObject& payload) {
clear_results();
if (!check_success(payload, [this](const QString& s) { display_error(s); }))
return;
const QString accent = module_.color.name();
const QString stype = payload.value("strategy_type").toString();
QString header_text = (stype.isEmpty() ? command : stype).toUpper();
header_text.replace('_', ' ');
results_layout_->addWidget(gs_section_header(header_text, accent));
if (command == "check_status") {
QList<QWidget*> top = {
gs_make_card(tr("QLIB"), payload.value("qlib_available").toBool() ? tr("AVAILABLE") : tr("MISSING"), this,
payload.value("qlib_available").toBool() ? ui::colors::POSITIVE() : ui::colors::NEGATIVE()),
gs_make_card(tr("PANDAS"), payload.value("pandas_available").toBool() ? tr("AVAILABLE") : tr("MISSING"),
this,
payload.value("pandas_available").toBool() ? ui::colors::POSITIVE() : ui::colors::NEGATIVE()),
gs_make_card(tr("NUMPY"), payload.value("numpy_available").toBool() ? tr("AVAILABLE") : tr("MISSING"), this,
payload.value("numpy_available").toBool() ? ui::colors::POSITIVE() : ui::colors::NEGATIVE()),
gs_make_card(tr("SCIPY"), payload.value("scipy_available").toBool() ? tr("AVAILABLE") : tr("MISSING"), this,
payload.value("scipy_available").toBool() ? ui::colors::POSITIVE() : ui::colors::NEGATIVE()),
};
results_layout_->addWidget(gs_card_row(top, this));
status_label_->setText(tr("Strategy builder ready"));
return;
}
// portfolio_metrics — a flat dict of stats
if (command == "portfolio_metrics") {
const double sh = payload.value("sharpe_ratio").toDouble();
const double ann = payload.value("annual_return").toDouble();
const double mdd = payload.value("max_drawdown").toDouble();
const double cal = payload.value("calmar_ratio").toDouble();
QList<QWidget*> top = {
gs_make_card(tr("ANN. RETURN"), fmt_pct_safe(QJsonValue(ann)), this, gs_pos_neg_color(ann)),
gs_make_card(tr("VOLATILITY"), fmt_pct_safe(payload.value("volatility")), this),
gs_make_card(tr("SHARPE"), QString::number(sh, 'f', 3), this,
sh >= 1.0 ? ui::colors::POSITIVE()
: sh > 0 ? ui::colors::WARNING()
: ui::colors::NEGATIVE()),
gs_make_card(tr("MAX DD"), fmt_pct_safe(QJsonValue(mdd)), this,
mdd <= -0.20 ? ui::colors::NEGATIVE() : ui::colors::WARNING()),
};
results_layout_->addWidget(gs_card_row(top, this));
QList<QWidget*> ratios = {
gs_make_card(tr("SORTINO"), QString::number(payload.value("sortino_ratio").toDouble(), 'f', 3), this,
payload.value("sortino_ratio").toDouble() >= 1.0 ? ui::colors::POSITIVE()
: ui::colors::WARNING()),
gs_make_card(tr("CALMAR"), QString::number(cal, 'f', 3), this,
cal >= 0.5 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
gs_make_card(tr("INFO RATIO"), QString::number(payload.value("information_ratio").toDouble(), 'f', 3), this,
payload.value("information_ratio").toDouble() > 0.5 ? ui::colors::POSITIVE()
: ui::colors::WARNING()),
gs_make_card(tr("BETA"), QString::number(payload.value("beta").toDouble(), 'f', 3), this),
};
results_layout_->addWidget(gs_card_row(ratios, this));
QList<QWidget*> day = {
gs_make_card(tr("WIN RATE"), QString::number(payload.value("win_rate").toDouble() * 100, 'f', 1) + "%",
this,
payload.value("win_rate").toDouble() > 0.55 ? ui::colors::POSITIVE() : ui::colors::WARNING()),
gs_make_card(tr("BEST DAY"), fmt_pct_safe(payload.value("best_day"), 3), this, ui::colors::POSITIVE()),
gs_make_card(tr("WORST DAY"), fmt_pct_safe(payload.value("worst_day"), 3), this, ui::colors::NEGATIVE()),
gs_make_card(tr("ALPHA"), fmt_pct_safe(payload.value("alpha"), 3), this,
gs_pos_neg_color(payload.value("alpha").toDouble())),
};
results_layout_->addWidget(gs_card_row(day, this));
status_label_->setText(tr("Annual %1% Sharpe %2 MaxDD %3%")
.arg(ann * 100, 0, 'f', 2)
.arg(sh, 0, 'f', 3)
.arg(mdd * 100, 0, 'f', 2));
return;
}
// Strategy creation commands — common fields: strategy_id, strategy_type, config?, weights?, suitable_for[]
QList<QWidget*> top = {
gs_make_card(tr("STRATEGY ID"), payload.value("strategy_id").toString(), this, ui::colors::POSITIVE()),
gs_make_card(tr("TYPE"), stype, this),
gs_make_card(tr("STATUS"), tr("CREATED"), this, ui::colors::POSITIVE()),
gs_make_card(tr("DESCRIPTION"), tr("↓ see below"), this, ui::colors::INFO()),
};
results_layout_->addWidget(gs_card_row(top, this));
// Risk parity / mean variance: weights present
if (payload.contains("weights")) {
const auto weights = payload.value("weights").toObject();
if (payload.contains("expected_return")) {
QList<QWidget*> mv = {
gs_make_card(tr("EXP. RETURN"), fmt_pct_safe(payload.value("expected_return")), this,
gs_pos_neg_color(payload.value("expected_return").toDouble())),
gs_make_card(tr("EXP. VOL"), fmt_pct_safe(payload.value("expected_volatility")), this),
gs_make_card(tr("SHARPE"), QString::number(payload.value("sharpe_ratio").toDouble(), 'f', 3), this,
payload.value("sharpe_ratio").toDouble() >= 1.0 ? ui::colors::POSITIVE()
: ui::colors::WARNING()),
gs_make_card(tr("RISK-FREE"), fmt_pct_safe(payload.value("risk_free_rate")), this, ui::colors::INFO()),
};
results_layout_->addWidget(gs_card_row(mv, this));
} else if (payload.contains("target_risk")) {
QList<QWidget*> rp = {
gs_make_card(tr("TARGET RISK"), fmt_pct_safe(payload.value("target_risk")), this),
gs_make_card(tr("EXP. VOL"),
payload.value("expected_volatility").isString()
? payload.value("expected_volatility").toString()
: fmt_pct_safe(payload.value("expected_volatility")),
this),
gs_make_card(tr("REBALANCE"), payload.value("rebalance_frequency").toString().toUpper(), this),
gs_make_card(tr("ASSETS"), QString::number(weights.size()), this),
};
results_layout_->addWidget(gs_card_row(rp, this));
}
results_layout_->addWidget(gs_section_header(tr("WEIGHTS"), accent));
results_layout_->addWidget(build_weights_table(weights, this));
// Risk parity scales the equal-risk weights to the target volatility, so they need not
// sum to 100%; show the gross exposure and the unscaled (fully invested) weights too.
if (payload.contains("gross_exposure")) {
auto* note = gs_section_header(tr("Scaled weights sum to %1% of capital to reach the target volatility "
"(100% = fully invested).")
.arg(payload.value("gross_exposure").toDouble() * 100.0, 0, 'f', 1),
accent);
note->setWordWrap(true);
results_layout_->addWidget(note);
const auto unscaled = payload.value("unscaled_weights").toObject();
if (!unscaled.isEmpty()) {
results_layout_->addWidget(gs_section_header(tr("UNSCALED WEIGHTS (FULLY INVESTED)"), accent));
results_layout_->addWidget(build_weights_table(unscaled, this));
}
}
} else if (payload.contains("config")) {
// TopK-Dropout / Enhanced Indexing / Weight Strategy: render config dict
const auto cfg = payload.value("config").toObject();
if (!cfg.isEmpty()) {
results_layout_->addWidget(gs_section_header(tr("CONFIG"), accent));
auto* table = new QTableWidget(cfg.size(), 2, this);
table->setHorizontalHeaderLabels({tr("Parameter"), tr("Value")});
table->verticalHeader()->setVisible(false);
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
table->setStyleSheet(table_ss());
table->setMaximumHeight(qMin(cfg.size() * 24 + 32, 240));
int r = 0;
for (auto it = cfg.begin(); it != cfg.end(); ++it, ++r) {
table->setItem(r, 0, new QTableWidgetItem(it.key().toUpper()));
auto* vi = new QTableWidgetItem(format_val(it.value()));
vi->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
table->setItem(r, 1, vi);
table->setRowHeight(r, 24);
}
results_layout_->addWidget(table);
}
// Show extra Enhanced-Indexing fields
if (payload.contains("expected_tracking_error") || payload.contains("expected_alpha")) {
QList<QWidget*> ei = {
gs_make_card(tr("TRACKING ERROR"), payload.value("expected_tracking_error").toString(), this),
gs_make_card(tr("ALPHA TARGET"), payload.value("expected_alpha").toString(), this,
ui::colors::POSITIVE()),
gs_make_card(tr("BENCHMARK"), payload.value("config").toObject().value("benchmark").toString(), this,
ui::colors::INFO()),
gs_make_card(
tr("ACTIVE SHARE"),
QString::number(payload.value("config").toObject().value("active_share").toDouble() * 100, 'f', 1) +
"%",
this),
};
results_layout_->addWidget(gs_card_row(ei, this));
} else if (payload.contains("expected_turnover")) {
QList<QWidget*> tk = {
gs_make_card(tr("EXPECTED TURNOVER"), payload.value("expected_turnover").toString(), this,
ui::colors::WARNING()),
};
results_layout_->addWidget(gs_card_row(tk, this));
}
}
// Description + suitable_for badges
const QString desc = payload.value("description").toString();
if (!desc.isEmpty()) {
auto* lbl = new QLabel(desc);
lbl->setWordWrap(true);
lbl->setStyleSheet(
QString("color:%1; font-size:11px; padding:8px 10px; background:%2; border-left:3px solid %3;")
.arg(ui::colors::TEXT_PRIMARY(), ui::colors::BG_SURFACE(), accent));
results_layout_->addWidget(lbl);
}
const auto sf = payload.value("suitable_for").toArray();
if (!sf.isEmpty()) {
QStringList sf_list;
for (const auto& v : sf)
sf_list << "• " + v.toString();
auto* sf_lbl = new QLabel(tr("Suitable for:\n%1").arg(sf_list.join("\n")));
sf_lbl->setWordWrap(true);
sf_lbl->setStyleSheet(QString("color:%1; font-size:10px; padding:6px 10px;").arg(ui::colors::TEXT_SECONDARY()));
results_layout_->addWidget(sf_lbl);
}
status_label_->setText(tr("%1 strategy created").arg(stype));
}
// ═════════════════════════════════════════════════════════════════════════════
// 8. DATA PROCESSORS
// ═════════════════════════════════════════════════════════════════════════════
} // namespace fincept::screens