Risk & Drawdown Panel

EnzoBlack · study · 354 行 · 点赞 3 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
// Risk & Drawdown Panel
// A plain risk panel for any symbol on a daily chart. It shows three things, all from the chart's own prices:
//   1. How far the price is below its highest close on the chart, and how that drawdown compares with the symbol's
//      own past drawdowns: deeper than how many of them, and longer than how many of them.
//   2. The volatility state: the ATR as a percent of the close, ranked against the symbol's own earlier days (the last
//      365 calendar days by default; 0 compares with all earlier days).
//   3. A position-size helper: the quantity that risks a chosen percent of the account with a stop a chosen number
//      of ATRs from the entry, and that stop's price.
// It describes this symbol's past only. It is not a signal and not a forecast.
//
// A line in its own pane, like an RSI, shows one of two things (setting "Line in the pane"):
//   - "Drawdown from the highest close": how far each day's close was below the highest close so far, in percent (0 at
//     a new high), with two step lines from the chart's own past: the median and the deepest of the past drawdowns
//     counted so far. On each bar they use only drawdowns that had ended by that bar's close, never a later bar.
//   - "Volatility rank (0-100)": that day's ATR as a percent of the close, ranked against the earlier days in the
//     window: the share of them with a lower reading, times 100. The line at 50 is the middle of that past, nothing more.
// The line marks no zones and gives no buy or sell reading: it shows where each day sat in this symbol's own past.
// The panel sits on the price chart.
//
// How it reads the chart. Only finished (confirmed) daily bars enter its history, so the drawdown and volatility
// sections are "as of the close" of the last finished day and never change afterwards. The position-size helper is
// the one exception: its entry is the chart's last price by default, which moves while the day is open; its stop
// distance uses the ATR of the last finished day.
//
// A drawdown starts when a close falls below the highest close so far and ends on the first close at or above that
// high. It counts as a past drawdown when its lowest close was at least the chosen size below the high. Its depth is
// that lowest close against the high; its length is the calendar days from the high to the close that got back to it.
// Today's drawdown is compared with those finished ones: how many were shallower at their lowest than today's depth,
// and how many lasted fewer days than today's has lasted so far.
//
// Made for a daily (1D) chart of standard candles, bars or a line. Days are dated by time_tradingday (00:00 UTC of the
// trading day), so a futures bar that opens the evening before keeps its own date. On any other timeframe or chart
// type it shows one row and nothing else. It requests no other symbol or timeframe.
indicator("Risk & Drawdown Panel", shorttitle="Risk & Drawdown", overlay=false, behind_chart=false)   // the line in its own pane; the panel on the price chart, in front of the candles (v6 defaults to behind)
 
// ---------- inputs ----------
GRP_L    = "Line"
LM_DD    = "Drawdown from the highest close"
LM_VOL   = "Volatility rank (0-100)"
lineMode = input.string(LM_DD, "Line in the pane", options=[LM_DD, LM_VOL], group=GRP_L, display=display.none, tooltip="What the line in this pane shows. Drawdown from the highest close: how far each day's close was below the highest close so far, in percent, with the median and the deepest of the past drawdowns counted up to that day. Volatility rank: each day's ATR as a percent of the close, ranked from 0 to 100 against the earlier days in the window set under Volatility (the share of them with a lower reading).")
GRP_H    = "Drawdowns"
fromDate = input.time(timestamp("1970-01-01T00:00:00"), "Compare with history from", group=GRP_H, display=display.none, tooltip="Only past drawdowns whose high was on or after this date, and only volatility readings from this date on, are used in the comparisons. The highest close is always the highest close on the whole chart. Leave it at 1970 to use all the history on the chart.")
minDepth = input.float(10.0, "Smallest drawdown counted (%)", minval=0.1, maxval=99.0, step=0.5, group=GRP_H, display=display.none, tooltip="A past fall from a highest close counts as a drawdown only if its lowest close was at least this many percent below that high. Smaller dips are left out of the comparison, so many tiny dips do not crowd out the real ones.")
minEp    = input.int(5, "Fewest past drawdowns needed", minval=1, group=GRP_H, display=display.none, tooltip="Today's drawdown is ranked against the past ones only if at least this many were counted. With fewer, the panel says so instead of showing a rank.")
GRP_V    = "Volatility"
atrLen   = input.int(14, "ATR length (days)", minval=1, group=GRP_V, display=display.none, tooltip="The number of daily bars in the Average True Range (Wilder's smoothing). It sets both the volatility reading and the stop distance in the position-size helper.")
volWin   = input.int(365, "Rank volatility against the last (days)", minval=0, group=GRP_V, display=display.none, tooltip="The volatility rank compares each day's ATR (as a percent of the close) with the readings of the days before it within this many calendar days, so a year is a year on any market, whatever its trading days. 0 compares with all earlier days. 'Compare with history from' still applies on top, and 'Fewest past days needed' counts the readings inside this window.")
minDays  = input.int(100, "Fewest past days needed", minval=1, group=GRP_V, display=display.none, tooltip="Today's ATR as a percent of the close is ranked against the past days only if at least this many past days inside the window have an ATR reading. With fewer, the panel says so instead of showing a rank.")
GRP_S    = "Position size"
acct     = input.float(10000.0, "Account size", minval=0.0, step=100.0, group=GRP_S, display=display.none, tooltip="Your account's value, in the symbol's quote currency (the currency the panel shows, for example USD on BTCUSD or USDT on BTCUSDT).")
riskPct  = input.float(1.0, "Risk per trade (% of account)", minval=0.0, maxval=100.0, step=0.1, group=GRP_S, display=display.none, tooltip="How much of the account you would lose if the stop is hit, in percent. The quantity is sized so that an exit exactly at the stop loses about this much, before fees, slippage and gaps through the stop.")
stopAtr  = input.float(2.0, "Stop distance (ATRs)", minval=0.1, step=0.1, group=GRP_S, display=display.none, tooltip="How far the stop sits from the entry, as a multiple of the ATR of the last finished day. 2 means two average daily ranges away.")
side     = input.string("Long", "Direction", options=["Long", "Short"], group=GRP_S, display=display.none, tooltip="Long puts the stop below the entry; Short puts it above.")
entryIn  = input.float(0.0, "Entry price (0 = last price)", minval=0.0, group=GRP_S, display=display.none, tooltip="The price you plan to enter at. Leave it at 0 to use the chart's last price, which moves while the day is open.")
qtyStep  = input.float(0.0, "Quantity step (0 = no rounding)", minval=0.0, group=GRP_S, display=display.none, tooltip="The smallest order size your exchange or broker allows, for example 0.001 for a coin or 1 for a share. The quantity is rounded DOWN to it, so the risk stays at or under your setting. At 0 the quantity is shown to three significant figures, also rounded down.")
GRP_D    = "Display"
showDD   = input.bool(true, "Show the drawdown section", group=GRP_D, display=display.none, tooltip="The drawdown from the highest close and how it compares with this symbol's past drawdowns.")
showVol  = input.bool(true, "Show the volatility section", group=GRP_D, display=display.none, tooltip="The ATR as a percent of the close and how it compares with this symbol's past days.")
showSize = input.bool(true, "Show the position-size section", group=GRP_D, display=display.none, tooltip="The quantity and stop price for your account size, risk and stop distance.")
tblPos   = input.string("Top right", "Panel position", options=["Top right", "Top left", "Bottom right", "Bottom left", "Middle right", "Middle left"], group=GRP_D, display=display.none, tooltip="Where the panel sits on the chart. If another script already has a table in the same place, one hides the other: pick a free corner.")
tblSize  = input.string("Small", "Panel text size", options=["Tiny", "Small", "Normal"], group=GRP_D, display=display.none, tooltip="The text size of the panel.")
 
DAY_MS = 86400000
// daily (1D) bars of a standard chart type only: other types (Heikin Ashi, Renko and the like) change the prices
okTf   = timeframe.isdaily and timeframe.multiplier == 1
okType = chart.is_standard
atrNow = ta.atr(atrLen)
 
// ---------- history, finished bars only ----------
var float   peak      = na      // highest close so far
var int     peakT     = na      // its trading day
var float   lowDD     = 0.0     // the open drawdown's lowest close against the high (0 or negative)
var int     lowT      = na
var float[] epDepth   = array.new_float()   // finished drawdowns: depth at the lowest close (negative)
var float[] epDays    = array.new_float()   // and calendar days from the high to the close that got back to it
var int[]   epPeakT   = array.new_int()
var float[] atrSorted = array.new_float()   // ATR / close of each finished day in the window, in ascending order
var int[]   atrT      = array.new_int()     // the same readings in the order they came in: their trading days
var float[] atrV      = array.new_float()   // and their values, so the oldest can leave the window
var int     atrFirstT = na
var int     atrLastT  = na
var int     firstT    = na
var int     lastT     = na      // the last finished day
var float   lastClose = na
var float   lastAtr   = na
var int     nBars     = 0
var float   medLine   = na      // the median and the deepest of the past drawdowns counted so far, in percent
var float   deepLine  = na
 
// how many values of an ascending array are strictly below v (binary search)
countBelow(array<float> a, float v) =>
    int lo = 0
    int hi = array.size(a)
    while lo < hi
        int mid = math.floor((lo + hi) / 2)
        if array.get(a, mid) < v
            lo := mid + 1
        else
            hi := mid
    lo
 
okBar = okTf and okType
// the volatility rank of this bar against the finished days before it inside the window: the arrays do not hold this
// bar yet, and readings that are older than the window as seen from this bar (the arrays drop them only when a bar
// finishes) are left out here, so the open bar never changes them
float rankLine = na
if okBar and not na(atrNow) and not na(close) and close > 0
    float v0 = atrNow / close
    int cnt = countBelow(atrSorted, v0)
    int n0 = array.size(atrSorted)
    if volWin > 0
        int cutoff = time_tradingday - volWin * DAY_MS
        int i = 0
        while i < array.size(atrT) and array.get(atrT, i) < cutoff
            if array.get(atrV, i) < v0
                cnt -= 1
            n0 -= 1
            i += 1
    if n0 >= minDays
        rankLine := cnt * 100.0 / n0
 
if okTf and okType and barstate.isconfirmed and not na(close)
    t = time_tradingday
    nBars += 1
    if na(firstT)
        firstT := t
    lastT     := t
    lastClose := close
    lastAtr   := atrNow
    if close > 0
        if na(peak) or close >= peak
            // the open drawdown, if any, has ended: keep it if it was deep enough and began on or after fromDate
            if lowDD < 0 and -lowDD * 100.0 >= minDepth and peakT >= fromDate
                array.push(epDepth, lowDD)
                array.push(epDays, math.round((t - peakT) / DAY_MS))
                array.push(epPeakT, peakT)
                medLine  := array.median(epDepth) * 100.0
                deepLine := array.min(epDepth) * 100.0
            peak  := close
            peakT := t
            lowDD := 0.0
            lowT  := na
        else
            dd = close / peak - 1.0
            if dd < lowDD
                lowDD := dd
                lowT  := t
    if volWin > 0     // readings older than the window, as seen from this finished day, leave it
        int cutoff = t - volWin * DAY_MS
        while array.size(atrT) > 0 and array.get(atrT, 0) < cutoff
            array.shift(atrT)
            float old = array.shift(atrV)
            array.remove(atrSorted, countBelow(atrSorted, old))   // the first value not below it is that reading
    if not na(atrNow) and close > 0 and t >= fromDate
        float v = atrNow / close
        array.insert(atrSorted, countBelow(atrSorted, v), v)
        array.push(atrT, t)
        array.push(atrV, v)
        if na(atrFirstT)
            atrFirstT := t
        atrLastT := t
 
// ---------- the line in this pane ----------
isDD = lineMode == LM_DD
// on a finished bar the peak already holds this close; on the open bar it holds the last finished one
float ddLine = okBar and not na(peak) and not na(close) and close > 0 ? (close / math.max(peak, close) - 1.0) * 100.0 : na
COL_LINE = #7E57C2
COL_MED  = #9598A1
COL_DEEP = #6A6D78
// only the mode in use shows, in the pane, the legend and the data window (no empty values for the other mode)
DISP_DD  = isDD ? display.all : display.none
DISP_VOL = isDD ? display.none : display.all
plot(isDD ? ddLine : na, "Drawdown from the highest close (%)", color=COL_LINE, linewidth=2, display=DISP_DD)
plot(isDD and okBar ? medLine : na, "Median past drawdown (%)", color=COL_MED, linewidth=1, style=plot.style_stepline, linestyle=plot.linestyle_dashed, display=DISP_DD)
plot(isDD and okBar ? deepLine : na, "Deepest past drawdown (%)", color=COL_DEEP, linewidth=1, style=plot.style_stepline, linestyle=plot.linestyle_dashed, display=DISP_DD)
plot(isDD ? na : rankLine, "Volatility rank (0-100)", color=COL_LINE, linewidth=2, display=DISP_VOL)
hline(isDD ? na : 50.0, "Middle of its own past (50)", color=color.new(color.gray, 30), linestyle=hline.style_dotted, display=DISP_VOL)
 
// labels at the right end of the two step lines: their values, history facts only. Each ends at the last bar and sits
// just above its line, so the price scale never cuts it off.
var label lbMed  = na
var label lbDeep = na
if barstate.islast
    label.delete(lbMed)
    label.delete(lbDeep)
    lbMed  := na
    lbDeep := na
    if isDD and okBar and not na(medLine)
        lbMed  := label.new(bar_index, medLine, "median past drop " + str.tostring(medLine, "0.0") + "% (" + str.tostring(array.size(epDepth)) + " counted)", style=label.style_label_lower_right, color=color.new(color.black, 100), textcolor=COL_MED, size=size.small)
        lbDeep := label.new(bar_index, deepLine, "deepest past drop " + str.tostring(deepLine, "0.0") + "%", style=label.style_label_lower_right, color=color.new(color.black, 100), textcolor=COL_DEEP, size=size.small)
 
// ---------- text helpers ----------
decimalsOf(float step) =>
    int d = 0
    if step > 0
        float s = step
        while d < 10 and math.abs(s - math.round(s)) > 1e-6 * math.max(1.0, math.abs(s))
            s *= 10
            d += 1
    d
numS(float x, int d) =>
    na(x) ? "-" : str.tostring(x, d <= 0 ? "#,##0" : "#,##0." + str.repeat("0", d))
PDEC = decimalsOf(syminfo.mintick)
priceS(float x) =>
    numS(x, PDEC)
pctS(float x, int d) =>
    na(x) ? "-" : str.tostring(x * 100.0, d <= 0 ? "0" : "0." + str.repeat("0", d)) + "%"
intS(float x) =>
    na(x) ? "-" : str.tostring(x, "#,##0")
dateS(int t) =>
    na(t) ? "-" : str.format_time(t, "yyyy-MM-dd", "UTC")
moneyS(float x) =>
    na(x) ? "-" : str.tostring(x, "#,##0.00") + " " + syminfo.currency
// three significant figures for a quantity with no step; always rounded down so the risk is never exceeded
sigDecimals(float q) =>
    q > 0 ? math.max(0, math.min(8, 2 - math.floor(math.log10(q)))) : 0
floorTo(float q, int d) =>
    float m = math.pow(10, d)
    math.floor(q * m + 1e-9) / m
 
// ---------- the panel: one table, one position ----------
pos = tblPos == "Top left" ? position.top_left : tblPos == "Bottom right" ? position.bottom_right : tblPos == "Bottom left" ? position.bottom_left : tblPos == "Middle right" ? position.middle_right : tblPos == "Middle left" ? position.middle_left : position.top_right
tsz = tblSize == "Tiny" ? size.tiny : tblSize == "Normal" ? size.normal : size.small
ROWS = 20
HEADBG = color.new(color.gray, 78)
var table tb = table.new(pos, 2, ROWS, bgcolor=color.new(chart.bg_color, 0), frame_color=color.new(color.gray, 50), frame_width=1, border_color=color.new(color.gray, 85), border_width=1, force_overlay=true)
 
putRow(int r, string a, string b, color bc) =>
    table.cell(tb, 0, r, a, text_color=chart.fg_color, text_size=tsz, text_halign=text.align_left)
    table.cell(tb, 1, r, b, text_color=bc, text_size=tsz, text_halign=text.align_left)
    r + 1
putHead(int r, string s) =>
    table.cell(tb, 0, r, s, text_color=chart.fg_color, bgcolor=HEADBG, text_size=tsz, text_halign=text.align_left)
    table.merge_cells(tb, 0, r, 1, r)
    r + 1
putNote(int r, string s) =>
    table.cell(tb, 0, r, s, text_color=color.gray, text_size=size.tiny, text_halign=text.align_left)
    table.merge_cells(tb, 0, r, 1, r)
    r + 1
 
if barstate.islast
    table.clear(tb, 0, 0, 1, ROWS - 1)
    fgc = chart.fg_color
    neg = color.red
    if not okTf
        putHead(0, "Risk & Drawdown Panel is made for a daily (1D) chart. Switch the chart to 1D to see it.")
    else if not okType
        putHead(0, "Risk & Drawdown Panel is made for standard candles, bars or a line. This chart type changes the prices, so it shows nothing here.")
    else if na(lastT)
        putHead(0, "Risk & Drawdown Panel: no finished daily bar on this chart yet.")
    else
        int r = 0
        r := putHead(r, "Risk & Drawdown Panel  |  " + syminfo.ticker + "  |  as of the close of " + dateS(lastT))
 
        // every branch below writes the same number of rows, so the merged rows keep their places
        if showDD
            r := putHead(r, "Drawdown from the highest close")
            bool havePeak = not na(peak)
            bool okNow = havePeak and not na(lastClose) and lastClose > 0
            float curDD = okNow ? math.min(0.0, lastClose / peak - 1.0) : na
            bool inDD = okNow and curDD < 0
            int curDays = inDD ? math.round((lastT - peakT) / DAY_MS) : 0
            r := putRow(r, "Highest close", havePeak ? priceS(peak) + " on " + dateS(peakT) : "no close above zero on this chart", fgc)
            r := putRow(r, "Now", not okNow ? "needs a close above zero" : inDD ? pctS(curDD, 1) + ", " + intS(curDays) + " days below it" : "at the highest close", inDD ? neg : fgc)
            r := putRow(r, "Lowest in this drawdown", inDD and not na(lowT) ? pctS(lowDD, 1) + " on " + dateS(lowT) : "-", inDD ? neg : fgc)
            n = array.size(epDepth)
            since = na(firstT) ? fromDate : math.max(fromDate, firstT)
            r := putRow(r, "Past drawdowns counted", intS(n) + " of " + str.tostring(minDepth, "0.#") + "% or more, since " + dateS(since), fgc)
            if not okNow
                r := putRow(r, "Depth now vs them", "-", fgc)
                r := putRow(r, "Length now vs them", "-", fgc)
            else if n < minEp
                tooFew = "too few to rank (" + intS(n) + "; needs " + intS(minEp) + ")"
                r := putRow(r, "Depth now vs them", tooFew, fgc)
                r := putRow(r, "Length now vs them", tooFew, fgc)
            else if not inDD
                r := putRow(r, "Depth now vs them", "no drawdown now", fgc)
                r := putRow(r, "Length now vs them", "no drawdown now", fgc)
            else
                int deeper = 0
                int longer = 0
                for i = 0 to n - 1
                    if array.get(epDepth, i) > curDD
                        deeper += 1
                    if array.get(epDays, i) < curDays
                        longer += 1
                r := putRow(r, "Depth now vs them", "deeper than " + intS(deeper) + " of " + intS(n) + " (" + pctS(deeper / n, 0) + ")", fgc)
                r := putRow(r, "Length now vs them", "longer than " + intS(longer) + " of " + intS(n) + " (" + pctS(longer / n, 0) + ")", fgc)
            if n > 0
                int wi = 0
                for i = 0 to n - 1
                    if array.get(epDepth, i) < array.get(epDepth, wi)
                        wi := i
                r := putRow(r, "Median past drawdown", pctS(array.median(epDepth), 1) + ", " + intS(array.median(epDays)) + " days below the high", fgc)
                r := putRow(r, "Deepest past drawdown", pctS(array.get(epDepth, wi), 1) + " from the high of " + dateS(array.get(epPeakT, wi)) + ", " + intS(array.get(epDays, wi)) + " days below it", fgc)
            else
                r := putRow(r, "Median past drawdown", "none counted", fgc)
                r := putRow(r, "Deepest past drawdown", "none counted", fgc)
 
        if showVol
            r := putHead(r, "Volatility: ATR " + str.tostring(atrLen) + " at the last close")
            if na(lastAtr) or na(lastClose) or lastClose <= 0
                r := putRow(r, "ATR", "needs " + intS(atrLen) + " daily bars; this chart has " + intS(nBars), fgc)
                r := putRow(r, "Against its own past", "-", fgc)
            else
                curA = lastAtr / lastClose
                r := putRow(r, "ATR", priceS(lastAtr) + " = " + pctS(curA, 2) + " of the close", fgc)
                nh = array.size(atrSorted)
                refN = atrLastT == lastT ? nh - 1 : nh     // the past days, without the last close itself
                if refN >= minDays
                    int lower = countBelow(atrSorted, curA)  // the last close's own value is not below itself
                    r := putRow(r, "Against its own past", volWin > 0 ? "higher than on " + pctS(lower / refN, 0) + " of the last " + intS(volWin) + " days" : "higher than on " + pctS(lower / refN, 0) + " of " + intS(refN) + " past days, since " + dateS(atrFirstT), fgc)
                else
                    r := putRow(r, "Against its own past", "too few past days to rank (" + intS(math.max(refN, 0)) + "; needs " + intS(minDays) + ")", fgc)
 
        if showSize
            isLong = side == "Long"
            r := putHead(r, "Position size: " + (isLong ? "long" : "short") + ", stop " + str.tostring(stopAtr, "0.0#") + " ATR " + (isLong ? "below" : "above") + " the entry")
            float entry = entryIn > 0 ? entryIn : close
            r := putRow(r, "Entry", priceS(entry) + (entryIn > 0 ? " (from the settings)" : " (last price)"), fgc)
            float pv = na(syminfo.pointvalue) or syminfo.pointvalue <= 0 ? 1.0 : syminfo.pointvalue
            float dist = stopAtr * lastAtr
            float stopP = na(dist) ? na : isLong ? entry - dist : entry + dist
            float riskAmt = acct * riskPct / 100.0
            // the stop's distance from the entry, signed: "-" below a long's entry, "+" above a short's
            string stopS = na(stopP) or na(entry) or entry <= 0 ? "-" : priceS(stopP) + " (" + (stopP > entry ? "+" : "") + pctS(stopP / entry - 1.0, 1) + ")"
            if na(lastAtr)
                r := putRow(r, "Stop", "needs " + intS(atrLen) + " daily bars for the ATR", fgc)
                r := putRow(r, "Risk at the stop", "-", fgc)
                r := putRow(r, "Quantity", "-", fgc)
                r := putRow(r, "Position value", "-", fgc)
            else if na(entry) or entry <= 0 or (isLong and stopP <= 0)
                r := putRow(r, "Stop", isLong and stopP <= 0 ? "at or below zero: use a smaller stop distance" : "needs an entry above zero", fgc)
                r := putRow(r, "Risk at the stop", "-", fgc)
                r := putRow(r, "Quantity", "-", fgc)
                r := putRow(r, "Position value", "-", fgc)
            else if acct <= 0 or riskPct <= 0
                r := putRow(r, "Stop", stopS, fgc)
                r := putRow(r, "Risk at the stop", "set an account size and a risk above zero", fgc)
                r := putRow(r, "Quantity", "-", fgc)
                r := putRow(r, "Position value", "-", fgc)
            else
                qRaw = riskAmt / (dist * pv)
                int qDec = qtyStep > 0 ? decimalsOf(qtyStep) : sigDecimals(qRaw)
                float qty = qtyStep > 0 ? math.floor(qRaw / qtyStep + 1e-9) * qtyStep : floorTo(qRaw, qDec)
                actRisk = qty * dist * pv
                posVal = qty * entry * pv
                r := putRow(r, "Stop", stopS, fgc)
                r := putRow(r, "Risk at the stop", moneyS(actRisk) + " = " + pctS(actRisk / acct, 2) + " of " + moneyS(acct), fgc)
                r := putRow(r, "Quantity", qty > 0 ? numS(qty, qDec) : "0: the quantity step is larger than this size", fgc)
                r := putRow(r, "Position value", moneyS(posVal) + " = " + pctS(posVal / acct, 0) + " of the account" + (posVal > acct ? " (larger than the account)" : ""), fgc)
 
        r := putNote(r, "Past drawdowns count at their lowest close and their full time below the high. This chart's own history only; not a forecast.")

← 返回列表