BackcastPro 0.0.5__py3-none-any.whl → 0.1.1__py3-none-any.whl

BackcastPro/__init__.py

@@ -3,11 +3,10 @@ BackcastPro をご利用いただきありがとうございます。
 
 インストール後のご案内（インストール済みユーザー向け）
 
-- ドキュメント総合トップ: https://botteryosuke.github.io/BackcastPro/
-- クイックスタート/チュートリアル: https://botteryosuke.github.io/BackcastPro/tutorial
-- APIリファレンス: https://botteryosuke.github.io/BackcastPro/api-reference
-- 高度な使い方: https://botteryosuke.github.io/BackcastPro/advanced-usage
-- トラブルシューティング: https://botteryosuke.github.io/BackcastPro/troubleshooting
+- ドキュメント総合トップ: [index.md](https://github.com/botterYosuke/BackcastPro/blob/main/docs/index.md)
+- クイックスタート/チュートリアル: [tutorial.md](https://github.com/botterYosuke/BackcastPro/blob/main/docs/tutorial.md)
+- APIリファレンス: [BackcastPro - APIリファレンス](https://botteryosuke.github.io/BackcastPro/namespacesrc_1_1BackcastPro.html)
+- トラブルシューティング: [troubleshooting.md](https://github.com/botterYosuke/BackcastPro/blob/main/docs/troubleshooting.md)
 
 ※ 使い始めはチュートリアル → 詳細はAPIリファレンスをご参照ください。
 """

BackcastPro/_broker.py

@@ -43,10 +43,9 @@ class _Broker:
         ヘッジングモードの有効化。Trueの場合、反対方向のポジションを同時に保有できます。
     exclusive_orders : bool
         排他的注文モード。Trueの場合、新しい注文が前のポジションを自動的にクローズします。
-    index : pd.Index
-        時系列データのインデックス。エクイティカーブの記録に使用されます。
     """
-    # Tips:
+
+    # ヒント:
     # 関数定義における`*`の意味
     # - `*`以降の引数は、必ずキーワード引数として渡す必要がある
     # - 位置引数として渡すことはできない
@@ -55,10 +54,10 @@ class _Broker:
     # 2. 保守性: 引数の順序を変更しても既存のコードが壊れない
     # 3. 可読性: 関数呼び出し時に何を渡しているかが分かりやすい
     def __init__(self, *, data, cash, spread, commission, margin,
-                 trade_on_close, hedging, exclusive_orders, index):
+                 trade_on_close, hedging, exclusive_orders):
         assert cash > 0, f"cash should be > 0, is {cash}"
         assert 0 < margin <= 1, f"margin should be between 0 and 1, is {margin}"
-        self._data: pd.DataFrame = data
+        self._data: dict[str, pd.DataFrame] = data
         self._cash = cash
 
         # 手数料の登録
@@ -83,7 +82,8 @@ class _Broker:
         self._hedging = hedging
         self._exclusive_orders = exclusive_orders
 
-        self._equity = np.tile(np.nan, len(index))
+        self._equity = []
+        self._current_time = None
         self.orders: List[Order] = []
         self.trades: List[Trade] = []
         self.position = Position(self)
@@ -92,10 +92,8 @@ class _Broker:
     def _commission_func(self, order_size, price):
         return self._commission_fixed + abs(order_size) * price * self._commission_relative
 
-    def __repr__(self):
-        return f'<Broker: {self._cash:.0f}{self.position.pl:+.1f} ({len(self.trades)} trades)>'
-
     def new_order(self,
+                  code: str,
                   size: float,
                   limit: Optional[float] = None,
                   stop: Optional[float] = None,
@@ -115,7 +113,7 @@ class _Broker:
 
         is_long = size > 0
         assert size != 0, size
-        adjusted_price = self._adjusted_price(size)
+        adjusted_price = self._adjusted_price(code, size)
 
         if is_long:
             if not (sl or -np.inf) < (limit or stop or adjusted_price) < (tp or np.inf):
@@ -128,7 +126,7 @@ class _Broker:
                     "Short orders require: "
                     f"TP ({tp}) < LIMIT ({limit or stop or adjusted_price}) < SL ({sl})")
 
-        order = Order(self, size, limit, stop, sl, tp, trade, tag)
+        order = Order(self, code, size, limit, stop, sl, tp, trade, tag)
 
         if not trade:
             # 排他的注文（各新しい注文が前の注文/ポジションを自動クローズ）の場合、
@@ -145,17 +143,16 @@ class _Broker:
 
         return order
 
-    @property
-    def last_price(self) -> float:
+    def last_price(self, code: str) -> float:
         """ Price at the last (current) close. """
-        return self._data.Close.iloc[-1]
+        return self._data[code].Close.iloc[-1]
 
-    def _adjusted_price(self, size=None, price=None) -> float:
+    def _adjusted_price(self, code: str, size=None, price=None) -> float:
         """
         Long/short `price`, adjusted for spread.
         In long positions, the adjusted price is a fraction higher, and vice versa.
         """
-        return (price or self.last_price) * (1 + copysign(self._spread, size))
+        return (price or self.last_price(code)) * (1 + copysign(self._spread, size))
 
     @property
     def equity(self) -> float:
@@ -175,35 +172,45 @@ class _Broker:
     def commission(self):
         return self._commission
 
-    def next(self):
-        i = self._i = len(self._data) - 1
+    def next(self, current_time: pd.Timestamp):
+        self._current_time = current_time
         self._process_orders()
 
         # エクイティカーブ用にアカウントエクイティを記録
         equity = self.equity
-        self._equity[i] = equity
+        self._equity.append(equity)
 
         # エクイティが負の場合、すべてを0に設定してシミュレーションを停止
         if equity <= 0:
             assert self.margin_available <= 0
             for trade in self.trades:
-                self._close_trade(trade, self._data.Close.iloc[-1], i)
+                price = self._data[trade.code].Close.iloc[-1]
+                self._close_trade(trade, price, self._current_time)
             self._cash = 0
-            self._equity[i:] = 0
             raise Exception
 
     def _process_orders(self):
         data = self._data
-        open, high, low = data.Open.iloc[-1], data.High.iloc[-1], data.Low.iloc[-1]
         reprocess_orders = False
 
         # 注文を処理
-        for order in list(self.orders):  # type: Order
+        for order in list(self.orders):  # 型: Order
 
             # 関連するSL/TP注文は既に削除されている
             if order not in self.orders:
                 continue
 
+            # 注文の銘柄データを取得
+            if order.code not in data:
+                continue
+            df = data[order.code]
+            
+            # データの存在確認
+            if len(df) == 0 or df.index[-1] != self._current_time:
+                continue
+                
+            open, high, low = df.Open.iloc[-1], df.High.iloc[-1], df.Low.iloc[-1]
+
             # ストップ条件が満たされたかチェック
             stop_price = order.stop
             if stop_price:
@@ -223,146 +230,143 @@ class _Broker:
                 # リミットがストップより先に満たされたと仮定する（つまり「カウントされる前に」）
                 is_limit_hit_before_stop = (is_limit_hit and
                                             (order.limit <= (stop_price or -np.inf)
-                                             if order.is_long
-                                             else order.limit >= (stop_price or np.inf)))
+                                            if order.is_long
+                                            else order.limit >= (stop_price or np.inf)))
                 if not is_limit_hit or is_limit_hit_before_stop:
                     continue
 
                 # stop_priceが設定されている場合、このバー内で満たされた
                 price = (min(stop_price or open, order.limit)
-                         if order.is_long else
-                         max(stop_price or open, order.limit))
+                        if order.is_long else
+                        max(stop_price or open, order.limit))
             else:
                 # 成行注文（Market-if-touched / market order）
                 # 条件付き注文は常に次の始値で
-                prev_close = data.Close.iloc[-2]
+                prev_close = df.Close.iloc[-2]
                 price = prev_close if self._trade_on_close and not order.is_contingent else open
                 if stop_price:
                     price = max(price, stop_price) if order.is_long else min(price, stop_price)
 
-            # エントリー/エグジットバーのインデックスを決定
-            is_market_order = not order.limit and not stop_price
-            time_index = (
-                (self._i - 1)
-                if is_market_order and self._trade_on_close and not order.is_contingent else
-                self._i)
-
-            # 注文がSL/TP注文の場合、それが依存していた既存の取引をクローズする必要がある
-            if order.parent_trade:
-                trade = order.parent_trade
-                _prev_size = trade.size
-                # order.sizeがtrade.sizeより「大きい」場合、この注文はtrade.close()注文で
-                # 取引の一部は事前にクローズされている
-                size = copysign(min(abs(_prev_size), abs(order.size)), order.size)
-                # この取引がまだクローズされていない場合（例：複数の`trade.close(.5)`呼び出し）
-                if trade in self.trades:
-                    self._reduce_trade(trade, price, size, time_index)
-                    assert order.size != -_prev_size or trade not in self.trades
-                    if price == stop_price:
-                        # 統計用にSLを注文に戻す
-                        trade._sl_order._replace(stop_price=stop_price)
-                if order in (trade._sl_order,
-                             trade._tp_order):
-                    assert order.size == -trade.size
-                    assert order not in self.orders  # 取引がクローズされたときに削除される
-                else:
-                    # trade.close()注文で、完了
-                    assert abs(_prev_size) >= abs(size) >= 1
-                    self.orders.remove(order)
-                continue
+                # エントリー/エグジットバーのインデックスを決定
+                is_market_order = not order.limit and not stop_price
+
+                # 注文がSL/TP注文の場合、それが依存していた既存の取引をクローズする必要がある
+                if order.parent_trade:
+                    trade = order.parent_trade
+                    _prev_size = trade.size
+                    # order.sizeがtrade.sizeより「大きい」場合、この注文はtrade.close()注文で
+                    # 取引の一部は事前にクローズされている
+                    size = copysign(min(abs(_prev_size), abs(order.size)), order.size)
+                    # この取引がまだクローズされていない場合（例：複数の`trade.close(.5)`呼び出し）
+                    if trade in self.trades:
+                        self._reduce_trade(trade, price, size, self._current_time)
+                        assert order.size != -_prev_size or trade not in self.trades
+                        if price == stop_price:
+                            # 統計用にSLを注文に戻す
+                            trade._sl_order._replace(stop_price=stop_price)
+                    if order in (trade._sl_order,
+                                trade._tp_order):
+                        assert order.size == -trade.size
+                        assert order not in self.orders  # 取引がクローズされたときに削除される
+                    else:
+                        # trade.close()注文で、完了
+                        assert abs(_prev_size) >= abs(size) >= 1
+                        self.orders.remove(order)
+                    continue
 
-            # そうでなければ、これは独立した取引
-
-            # 手数料（またはビッドアスクスプレッド）を含むように価格を調整
-            # ロングポジションでは調整価格が少し高くなり、その逆も同様
-            adjusted_price = self._adjusted_price(order.size, price)
-            adjusted_price_plus_commission = \
-                adjusted_price + self._commission(order.size, price) / abs(order.size)
-
-            # 注文サイズが比例的に指定された場合、
-            # マージンとスプレッド/手数料を考慮して、単位での真のサイズを事前計算
-            size = order.size
-            if -1 < size < 1:
-                size = copysign(int((self.margin_available * self._leverage * abs(size))
-                                    // adjusted_price_plus_commission), size)
-                # 単一ユニットでも十分な現金/マージンがない
-                if not size:
-                    warnings.warn(
-                        f'time={self._i}: ブローカーは相対サイズの注文を'
-                        f'不十分なマージンのためキャンセルしました。', category=UserWarning)
-                    # XXX: 注文はブローカーによってキャンセルされる？
+                # そうでなければ、これは独立した取引
+
+                # 手数料（またはビッドアスクスプレッド）を含むように価格を調整
+                # ロングポジションでは調整価格が少し高くなり、その逆も同様
+                adjusted_price = self._adjusted_price(code=order.code, size=order.size, price=price)
+                adjusted_price_plus_commission = \
+                    adjusted_price + self._commission(order.size, price) / abs(order.size)
+
+                # 注文サイズが比例的に指定された場合、
+                # マージンとスプレッド/手数料を考慮して、単位での真のサイズを事前計算
+                size = order.size
+                if -1 < size < 1:
+                    size = copysign(int((self.margin_available * self._leverage * abs(size))
+                                        // adjusted_price_plus_commission), size)
+                    # 単一ユニットでも十分な現金/マージンがない
+                    if not size:
+                        warnings.warn(
+                            f'{self._current_time}: ブローカーは相対サイズの注文を'
+                            f'不十分なマージンのためキャンセルしました。', category=UserWarning)
+                        # XXX: 注文はブローカーによってキャンセルされる？
+                        self.orders.remove(order)
+                        continue
+                assert size == round(size)
+                need_size = int(size)
+
+                if not self._hedging:
+                    # 既存の反対方向の取引をFIFOでクローズ/削減してポジションを埋める
+                    # 既存の取引は調整価格でクローズされる（調整は購入時に既に行われているため）
+                    for trade in list(self.trades):
+                        if trade.is_long == order.is_long:
+                            continue
+                        assert trade.size * order.size < 0
+
+                        # 注文サイズがこの反対方向の既存取引より大きい場合、
+                        # 完全にクローズされる
+                        if abs(need_size) >= abs(trade.size):
+                            self._close_trade(trade, price, self._current_time)
+                            need_size += trade.size
+                        else:
+                            # 既存の取引が新しい注文より大きい場合、
+                            # 部分的にのみクローズされる
+                            self._reduce_trade(trade, price, need_size, self._current_time)
+                            need_size = 0
+
+                        if not need_size:
+                            break
+
+                # 注文をカバーするのに十分な流動性がない場合、ブローカーはそれをキャンセルする
+                if abs(need_size) * adjusted_price_plus_commission > \
+                        self.margin_available * self._leverage:
                     self.orders.remove(order)
                     continue
-            assert size == round(size)
-            need_size = int(size)
-
-            if not self._hedging:
-                # 既存の反対方向の取引をFIFOでクローズ/削減してポジションを埋める
-                # 既存の取引は調整価格でクローズされる（調整は購入時に既に行われているため）
-                for trade in list(self.trades):
-                    if trade.is_long == order.is_long:
-                        continue
-                    assert trade.size * order.size < 0
-
-                    # 注文サイズがこの反対方向の既存取引より大きい場合、
-                    # 完全にクローズされる
-                    if abs(need_size) >= abs(trade.size):
-                        self._close_trade(trade, price, time_index)
-                        need_size += trade.size
-                    else:
-                        # 既存の取引が新しい注文より大きい場合、
-                        # 部分的にのみクローズされる
-                        self._reduce_trade(trade, price, need_size, time_index)
-                        need_size = 0
 
-                    if not need_size:
-                        break
-
-            # 注文をカバーするのに十分な流動性がない場合、ブローカーはそれをキャンセルする
-            if abs(need_size) * adjusted_price_plus_commission > \
-                    self.margin_available * self._leverage:
+                # 新しい取引を開始
+                if need_size:
+                    self._open_trade(order.code,
+                                    adjusted_price,
+                                    need_size,
+                                    order.sl,
+                                    order.tp,
+                                    self._current_time,
+                                    order.tag)
+
+                    # 新しくキューに追加されたSL/TP注文を再処理する必要がある
+                    # これにより、注文が開かれた同じバーでSLがヒットすることを可能にする
+                    # https://github.com/kernc/backtesting.py/issues/119 を参照
+                    if order.sl or order.tp:
+                        if is_market_order:
+                            reprocess_orders = True
+                        # Order.stopとTPが同じバー内でヒットしたが、SLはヒットしなかった。この場合
+                        # ストップとTPが同じ価格方向に進むため、曖昧ではない
+                        elif stop_price and not order.limit and order.tp and (
+                                (order.is_long and order.tp <= high and (order.sl or -np.inf) < low) or
+                                (order.is_short and order.tp >= low and (order.sl or np.inf) > high)):
+                            reprocess_orders = True
+                        elif (low <= (order.sl or -np.inf) <= high or
+                            low <= (order.tp or -np.inf) <= high):
+                            warnings.warn(
+                                f"({df.index[-1]}) 条件付きSL/TP注文が、その親ストップ/リミット注文が取引に"
+                                "変換された同じバーで実行されることになります。"
+                                "正確なローソク足内価格変動を断言できないため、"
+                                "影響を受けるSL/TP注文は代わりに次の（マッチングする）価格/バーで"
+                                "実行され、結果（この取引の）が幾分疑わしいものになります。"
+                                "https://github.com/kernc/backtesting.py/issues/119 を参照",
+                                UserWarning)
+
+                # 注文処理完了
                 self.orders.remove(order)
-                continue
-
-            # 新しい取引を開始
-            if need_size:
-                self._open_trade(adjusted_price,
-                                 need_size,
-                                 order.sl,
-                                 order.tp,
-                                 time_index,
-                                 order.tag)
-
-                # 新しくキューに追加されたSL/TP注文を再処理する必要がある
-                # これにより、注文が開かれた同じバーでSLがヒットすることを可能にする
-                # https://github.com/kernc/backtesting.py/issues/119 を参照
-                if order.sl or order.tp:
-                    if is_market_order:
-                        reprocess_orders = True
-                    # Order.stopとTPが同じバー内でヒットしたが、SLはヒットしなかった。この場合
-                    # ストップとTPが同じ価格方向に進むため、曖昧ではない
-                    elif stop_price and not order.limit and order.tp and (
-                            (order.is_long and order.tp <= high and (order.sl or -np.inf) < low) or
-                            (order.is_short and order.tp >= low and (order.sl or np.inf) > high)):
-                        reprocess_orders = True
-                    elif (low <= (order.sl or -np.inf) <= high or
-                          low <= (order.tp or -np.inf) <= high):
-                        warnings.warn(
-                            f"({data.index[-1]}) 条件付きSL/TP注文が、その親ストップ/リミット注文が取引に"
-                            "変換された同じバーで実行されることになります。"
-                            "正確なローソク足内価格変動を断言できないため、"
-                            "影響を受けるSL/TP注文は代わりに次の（マッチングする）価格/バーで"
-                            "実行され、結果（この取引の）が幾分疑わしいものになります。"
-                            "https://github.com/kernc/backtesting.py/issues/119 を参照",
-                            UserWarning)
-
-            # 注文処理完了
-            self.orders.remove(order)
 
         if reprocess_orders:
             self._process_orders()
 
-    def _reduce_trade(self, trade: Trade, price: float, size: float, time_index: int):
+    def _reduce_trade(self, trade: Trade, price: float, size: float, current_time: pd.Timestamp):
         assert trade.size * size < 0
         assert abs(trade.size) >= abs(size)
 
@@ -371,44 +375,44 @@ class _Broker:
         if not size_left:
             close_trade = trade
         else:
-            # Reduce existing trade ...
+            # 既存の取引を削減...
             trade._replace(size=size_left)
             if trade._sl_order:
                 trade._sl_order._replace(size=-trade.size)
             if trade._tp_order:
                 trade._tp_order._replace(size=-trade.size)
 
-            # ... by closing a reduced copy of it
+            # ... その削減コピーをクローズすることによって
             close_trade = trade._copy(size=-size, sl_order=None, tp_order=None)
             self.trades.append(close_trade)
 
-        self._close_trade(close_trade, price, time_index)
+        self._close_trade(close_trade, price, current_time)
 
-    def _close_trade(self, trade: Trade, price: float, time_index: int):
+    def _close_trade(self, trade: Trade, price: float, current_time: pd.Timestamp):
         self.trades.remove(trade)
         if trade._sl_order:
             self.orders.remove(trade._sl_order)
         if trade._tp_order:
             self.orders.remove(trade._tp_order)
 
-        closed_trade = trade._replace(exit_price=price, exit_bar=time_index)
+        closed_trade = trade._replace(exit_price=price, exit_time=current_time)
         self.closed_trades.append(closed_trade)
-        # Apply commission one more time at trade exit
+        # 取引終了時に手数料を再度適用
         commission = self._commission(trade.size, price)
         self._cash += trade.pl - commission
-        # Save commissions on Trade instance for stats
+        # 統計用にTradeインスタンスに手数料を保存
         trade_open_commission = self._commission(closed_trade.size, closed_trade.entry_price)
-        # applied here instead of on Trade open because size could have changed
-        # by way of _reduce_trade()
+        # サイズが_reduce_trade()によって変更された可能性があるため、
+        # Trade開始時ではなくここで適用
         closed_trade._commissions = commission + trade_open_commission
 
-    def _open_trade(self, price: float, size: int,
-                    sl: Optional[float], tp: Optional[float], time_index: int, tag):
-        trade = Trade(self, size, price, time_index, tag)
+    def _open_trade(self, code: str, price: float, size: int,
+                    sl: Optional[float], tp: Optional[float], current_time: pd.Timestamp, tag):
+        trade = Trade(self, code, size, price, current_time, tag)
         self.trades.append(trade)
-        # Apply broker commission at trade open
+        # 取引開始時にブローカー手数料を適用
         self._cash -= self._commission(size, price)
-        # Create SL/TP (bracket) orders.
+        # SL/TP（ブラケット）注文を作成。
         if tp:
             trade.tp = tp
         if sl:

BackcastPro/_stats.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 from numbers import Number
 from typing import TYPE_CHECKING, List, Union, cast
 
@@ -16,7 +17,7 @@ def compute_drawdown_duration_peaks(dd: pd.Series):
     df = iloc.to_frame('iloc').assign(prev=iloc.shift())
     df = df[df['iloc'] > df['prev'] + 1].astype(np.int64)
 
-    # 取引がないためドローダウンがない場合、pandasのために以下を回避し、nanシリーズを返す
+    # 取引がないためドローダウンがない場合、pandasの都合上以下を避けてnanシリーズを返す
     if not len(df):
         return (dd.replace(0, np.nan),) * 2
 
@@ -25,7 +26,6 @@ def compute_drawdown_duration_peaks(dd: pd.Series):
     df = df.reindex(dd.index)
     return df['duration'], df['peak_dd']
 
-
 def geometric_mean(returns: pd.Series) -> float:
     returns = returns.fillna(0) + 1
     if np.any(returns <= 0):
@@ -33,20 +33,27 @@ def geometric_mean(returns: pd.Series) -> float:
     return np.exp(np.log(returns).sum() / (len(returns) or np.nan)) - 1
 
 def _data_period(index) -> Union[pd.Timedelta, Number]:
-    """Return data index period as pd.Timedelta"""
+    """データインデックスの期間をpd.Timedeltaとして返す"""
     values = pd.Series(index[-100:])
     return values.diff().dropna().median()
 
 def compute_stats(
         trades: Union[List['Trade'], pd.DataFrame],
         equity: np.ndarray,
-        ohlc_data: pd.DataFrame,
+        index: pd.DatetimeIndex,
         strategy_instance: Strategy | None,
         risk_free_rate: float = 0,
 ) -> pd.Series:
     assert -1 < risk_free_rate < 1
 
-    index = ohlc_data.index
+   
+    # エクイティカーブとインデックスの長さを一致させる
+    if len(equity) > len(index):
+        equity = equity[:len(index)]
+    elif len(equity) < len(index):
+        # エクイティカーブが短い場合は、0で埋める
+        equity = np.concatenate([equity, np.full(len(index) - len(equity), 0)])
+    
     dd = 1 - equity / np.maximum.accumulate(equity)
     dd_dur, dd_peaks = compute_drawdown_duration_peaks(pd.Series(dd, index=index))
 
@@ -60,8 +67,9 @@ def compute_stats(
         trades_df: pd.DataFrame = trades
         commissions = None  # Not shown
     else:
-        # Came straight from Backtest.run()
+        # Backtest.run()から直接来たデータ
         trades_df = pd.DataFrame({
+            'Code': [t.code for t in trades],
             'Size': [t.size for t in trades],
             'EntryBar': [t.entry_bar for t in trades],
             'ExitBar': [t.exit_bar for t in trades],
@@ -100,7 +108,7 @@ def compute_stats(
     for t in trades_df.itertuples(index=False):
         have_position[t.EntryBar:t.ExitBar + 1] = 1
 
-    s.loc['Exposure Time [%]'] = have_position.mean() * 100  # In "n bars" time, not index time
+    s.loc['Exposure Time [%]'] = have_position.mean() * 100  # "n bars"時間単位、インデックス時間ではない
     s.loc['Equity Final [$]'] = equity[-1]
     s.loc['Equity Peak [$]'] = equity.max()
     if commissions:
@@ -123,10 +131,10 @@ def compute_stats(
         day_returns = equity_df['Equity'].resample(freq).last().dropna().pct_change()
         gmean_day_return = geometric_mean(day_returns)
 
-    # Annualized return and risk metrics are computed based on the (mostly correct)
-    # assumption that the returns are compounded. See: https://dx.doi.org/10.2139/ssrn.3054517
-    # Our annualized return matches `empyrical.annual_return(day_returns)` whereas
-    # our risk doesn't; they use the simpler approach below.
+    # 年率化リターンとリスク指標は、リターンが複利計算されるという（ほぼ正確な）
+    # 仮定に基づいて計算される。参照: https://dx.doi.org/10.2139/ssrn.3054517
+    # 我々の年率化リターンは`empyrical.annual_return(day_returns)`と一致するが、
+    # リスクは一致しない。彼らは以下のより単純なアプローチを使用している。
     annualized_return = (1 + gmean_day_return)**annual_trading_days - 1
     s.loc['Return (Ann.) [%]'] = annualized_return * 100
     s.loc['Volatility (Ann.) [%]'] = np.sqrt((day_returns.var(ddof=int(bool(day_returns.shape))) + (1 + gmean_day_return)**2)**annual_trading_days - (1 + gmean_day_return)**(2 * annual_trading_days)) * 100  # noqa: E501
@@ -136,10 +144,10 @@ def compute_stats(
         time_in_years = (s.loc['Duration'].days + s.loc['Duration'].seconds / 86400) / annual_trading_days
         s.loc['CAGR [%]'] = ((s.loc['Equity Final [$]'] / equity[0])**(1 / time_in_years) - 1) * 100 if time_in_years else np.nan  # noqa: E501
 
-    # Our Sharpe mismatches `empyrical.sharpe_ratio()` because they use arithmetic mean return
-    # and simple standard deviation
+    # 我々のSharpeは`empyrical.sharpe_ratio()`と一致しない。彼らは算術平均リターン
+    # と単純な標準偏差を使用するため
     s.loc['Sharpe Ratio'] = (s.loc['Return (Ann.) [%]'] - risk_free_rate * 100) / (s.loc['Volatility (Ann.) [%]'] or np.nan)  # noqa: E501
-    # Our Sortino mismatches `empyrical.sortino_ratio()` because they use arithmetic mean return
+    # 我々のSortinoは`empyrical.sortino_ratio()`と一致しない。彼らは算術平均リターンを使用するため
     with np.errstate(divide='ignore'):
         s.loc['Sortino Ratio'] = (annualized_return - risk_free_rate) / (np.sqrt(np.mean(day_returns.clip(-np.inf, 0)**2)) * np.sqrt(annual_trading_days))  # noqa: E501
     max_dd = -np.nan_to_num(dd.max())