Index

Modules: terminal_graph, terminal_graph/bar_graphs, terminal_graph/candle_graphs, terminal_graph/line_graphs, terminal_graph/live_graphs, terminal_graph/multiplot_graphs, terminal_graph/sparkline_graphs, terminal_graph/static_graphs, terminal_graph/surface_graphs, terminal_graph/xy_graphs.

API symbols

addSeries:

• live_graphs: proc addSeries(graph: var LiveGraph; name: string; style = psLine; color = fgCyan; marker = "•"): int
• static_graphs: proc addSeries(plotter: var Plotter; name: string; style = psLine; color = fgCyan; marker = "•"): int

AsciiGraphConfig:

• line_graphs: object AsciiGraphConfig

autoColumns:

• multiplot_graphs: const autoColumns

axisOffset:

• line_graphs: proc axisOffset(value: int): LineGraphOption

AxisValueFormatter:

• line_graphs: type AxisValueFormatter

BarGraphOptions:

• bar_graphs: object BarGraphOptions

BarMode:

• bar_graphs: enum BarMode

bmGrouped:

• bar_graphs: BarMode.bmGrouped

bmStacked:

• bar_graphs: BarMode.bmStacked

Candle:

• candle_graphs: object Candle

candle:

• candle_graphs: proc candle[O, H, L, C: SomeNumber](open: O; high: H; low: L; close: C): Candle

candleCount:

• live_graphs: proc candleCount(graph: LiveCandleGraph): int

CandlePlotOptions:

• candle_graphs: object CandlePlotOptions

clear:

• live_graphs: proc clear(graph: var LiveCandleGraph)
• live_graphs: proc clear(graph: var LiveGraph)
• live_graphs: proc clear(graph: var LiveLineGraph)
• static_graphs: proc clear(plotter: var Plotter)
• static_graphs: proc clear(plotter: var Plotter; seriesIdx: int)

clearBarRange:

• bar_graphs: proc clearBarRange(options: var BarGraphOptions)

clearCandleRange:

• candle_graphs: proc clearCandleRange(options: var CandlePlotOptions)

clearLines:

• line_graphs: proc clearLines(lineCount: int)

clearLinesSequence:

• line_graphs: proc clearLinesSequence(lineCount: int): string

clearRange:

• live_graphs: proc clearRange(graph: var LiveCandleGraph)
• live_graphs: proc clearRange(graph: var LiveGraph)
• static_graphs: proc clearRange(plotter: var Plotter)

clearSparklineMaximum:

• sparkline_graphs: proc clearSparklineMaximum(options: var SparklineOptions)

clearSparklineMinimum:

• sparkline_graphs: proc clearSparklineMinimum(options: var SparklineOptions)

clearSparklineRange:

• sparkline_graphs: proc clearSparklineRange(options: var SparklineOptions)

clearSurfaceRange:

• surface_graphs: proc clearSurfaceRange(options: var SurfacePlotOptions)

clearTerminal:

• line_graphs: proc clearTerminal()

clearXRange:

• xy_graphs: proc clearXRange(options: var XYPlotOptions)

clearYRange:

• xy_graphs: proc clearYRange(options: var XYPlotOptions)

createLineCharSet:

• line_graphs: proc createLineCharSet(character: string): LineCharSet

DefaultBarColors:

• bar_graphs: const DefaultBarColors

DefaultLineCharSet:

• line_graphs: const DefaultLineCharSet

DefaultMaxSamples:

• static_graphs: const DefaultMaxSamples

DefaultXYColors:

• xy_graphs: const DefaultXYColors

draw:

• live_graphs: proc draw(graph: var LiveCandleGraph)
• live_graphs: proc draw(dashboard: LiveDashboard; frame: string)
• live_graphs: proc draw(graph: LiveGraph)
• live_graphs: proc draw(graph: var LiveLineGraph)

FireSparklinePalette:

• sparkline_graphs: const FireSparklinePalette

fixedColumns:

• multiplot_graphs: proc fixedColumns(count: int): MultiplotColumns

graphAxisColor:

• line_graphs: proc graphAxisColor(value: TerminalColor): LineGraphOption

graphCaption:

• line_graphs: proc graphCaption(value: string): LineGraphOption

graphCaptionColor:

• line_graphs: proc graphCaptionColor(value: TerminalColor): LineGraphOption

graphColorAbove:

• line_graphs: proc graphColorAbove(color: TerminalColor; threshold: float64): LineGraphOption

graphColorBelow:

• line_graphs: proc graphColorBelow(color: TerminalColor; threshold: float64): LineGraphOption

graphColorGradient:

• line_graphs: proc graphColorGradient(stops: openArray[TerminalColor]): LineGraphOption

graphHeight:

• line_graphs: proc graphHeight(value: int): LineGraphOption

graphLabelColor:

• line_graphs: proc graphLabelColor(value: TerminalColor): LineGraphOption

graphLineEnding:

• line_graphs: proc graphLineEnding(value: string): LineGraphOption

graphSeriesChars:

• line_graphs: proc graphSeriesChars(values: openArray[LineCharSet]): LineGraphOption

graphSeriesColors:

• line_graphs: proc graphSeriesColors(values: openArray[TerminalColor]): LineGraphOption

graphSeriesLegends:

• line_graphs: proc graphSeriesLegends(values: openArray[string]): LineGraphOption

graphWidth:

• line_graphs: proc graphWidth(value: int): LineGraphOption

graphXAxisFormatter:

• line_graphs: proc graphXAxisFormatter(formatter: AxisValueFormatter): LineGraphOption

graphXAxisRange:

• line_graphs: proc graphXAxisRange(minimum, maximum: float64): LineGraphOption

graphXAxisTickCount:

• line_graphs: proc graphXAxisTickCount(value: int): LineGraphOption

graphYAxisFormatter:

• line_graphs: proc graphYAxisFormatter(formatter: AxisValueFormatter): LineGraphOption

HeatmapSpectrum:

• line_graphs: const HeatmapSpectrum

initAsciiGraphConfig:

• line_graphs: proc initAsciiGraphConfig(): AsciiGraphConfig

initBarGraphOptions:

• bar_graphs: proc initBarGraphOptions(): BarGraphOptions

initCandlePlotOptions:

• candle_graphs: proc initCandlePlotOptions(): CandlePlotOptions

initLiveCandleGraph:

• live_graphs: proc initLiveCandleGraph(maxCandles = 80; options = initCandlePlotOptions(); output: File = stdout): LiveCandleGraph

initLiveDashboard:

• live_graphs: proc initLiveDashboard(alternateScreen = true; output: File = stdout): LiveDashboard

initLiveGraph:

• live_graphs: proc initLiveGraph(title: string; unit = ""; maxSamples = DefaultMaxSamples; width = 0; height = 0; useColor = true; showStats = true): LiveGraph

initLiveLineGraph:

• live_graphs: proc initLiveLineGraph(seriesCount = 1; maxSamples = 80; config = initAsciiGraphConfig(); output: File = stdout): LiveLineGraph

initMultiplotOptions:

• multiplot_graphs: proc initMultiplotOptions(): MultiplotOptions

initPlotter:

• static_graphs: proc initPlotter(title: string; unit = ""; maxSamples = DefaultMaxSamples): Plotter

initSparklineOptions:

• sparkline_graphs: proc initSparklineOptions(): SparklineOptions

initStaticGraph:

• static_graphs: proc initStaticGraph(title: string; unit = ""; maxSamples = DefaultMaxSamples): StaticGraph

initSurfacePlotOptions:

• surface_graphs: proc initSurfacePlotOptions(): SurfacePlotOptions

initXYPlotOptions:

• xy_graphs: proc initXYPlotOptions(): XYPlotOptions

initXYSeries:

• xy_graphs: proc initXYSeries(name: string; points: openArray[XYPoint]; color = colorDefault; marker = "●"; connect = true): XYSeries

isActive:

• live_graphs: proc isActive(graph: LiveCandleGraph): bool
• live_graphs: proc isActive(dashboard: LiveDashboard): bool
• live_graphs: proc isActive(graph: LiveGraph): bool
• live_graphs: proc isActive(graph: LiveLineGraph): bool

labelPrecision:

• line_graphs: proc labelPrecision(value: Natural): LineGraphOption

latest:

• static_graphs: proc latest(plotter: Plotter; seriesIdx: int): Option[float64]

latestCandle:

• live_graphs: proc latestCandle(graph: LiveCandleGraph): Option[Candle]

LineCharSet:

• line_graphs: object LineCharSet

LineGraphOption:

• line_graphs: type LineGraphOption

LiveCandleGraph:

• live_graphs: object LiveCandleGraph

LiveDashboard:

• live_graphs: object LiveDashboard

LiveGraph:

• live_graphs: object LiveGraph

LiveLineGraph:

• live_graphs: object LiveLineGraph

lowerBound:

• line_graphs: proc lowerBound(value: float64): LineGraphOption

maxSamples:

• static_graphs: proc maxSamples(plotter: Plotter): int

mckAuto:

• multiplot_graphs: MultiplotColumnKind.mckAuto

mckFixed:

• multiplot_graphs: MultiplotColumnKind.mckFixed

mhaCenter:

• multiplot_graphs: MultiplotHorizontalAlignment.mhaCenter

mhaLeft:

• multiplot_graphs: MultiplotHorizontalAlignment.mhaLeft

mhaRight:

• multiplot_graphs: MultiplotHorizontalAlignment.mhaRight

MinimumRenderHeight:

• static_graphs: const MinimumRenderHeight

MinimumRenderWidth:

• static_graphs: const MinimumRenderWidth

multiplot:

• multiplot_graphs: proc multiplot(plots: openArray[string]; columns = 0; horizontalGap = 3; verticalGap = 1): string
• multiplot_graphs: proc multiplot(plots: openArray[string]; options: MultiplotOptions): string

MultiplotBreakpoint:

• multiplot_graphs: object MultiplotBreakpoint

multiplotBreakpoint:

• multiplot_graphs: proc multiplotBreakpoint(minimumWidth, columns: int): MultiplotBreakpoint

MultiplotColumnKind:

• multiplot_graphs: enum MultiplotColumnKind

MultiplotColumns:

• multiplot_graphs: object MultiplotColumns

MultiplotHorizontalAlignment:

• multiplot_graphs: enum MultiplotHorizontalAlignment

MultiplotOptions:

• multiplot_graphs: object MultiplotOptions

MultiplotRenderer:

• multiplot_graphs: type MultiplotRenderer

multiplotResponsive:

• multiplot_graphs: proc multiplotResponsive(renderers: openArray[MultiplotRenderer]; options = initMultiplotOptions()): string

MultiplotVerticalAlignment:

• multiplot_graphs: enum MultiplotVerticalAlignment

mvaBottom:

• multiplot_graphs: MultiplotVerticalAlignment.mvaBottom

mvaMiddle:

• multiplot_graphs: MultiplotVerticalAlignment.mvaMiddle

mvaTop:

• multiplot_graphs: MultiplotVerticalAlignment.mvaTop

plot:

• line_graphs: proc plot[T: SomeNumber](series: openArray[T]; config: AsciiGraphConfig): string
• line_graphs: proc plot[T: SomeNumber](series: openArray[T]; options: varargs[LineGraphOption]): string

plot2D:

• surface_graphs: proc plot2D[T: SomeNumber](data: openArray[T]; columns: int; options = initSurfacePlotOptions()): string

plotBars:

• bar_graphs: proc plotBars[T: SomeNumber](labels: openArray[string]; series: openArray[seq[T]]): string
• bar_graphs: proc plotBars[T: SomeNumber](labels: openArray[string]; series: openArray[seq[T]]; options: BarGraphOptions): string
• bar_graphs: proc plotBars[T: SomeNumber](labels: openArray[string]; values: openArray[T]): string
• bar_graphs: proc plotBars[T: SomeNumber](labels: openArray[string]; values: openArray[T]; options: BarGraphOptions): string

plotCandles:

• candle_graphs: proc plotCandles(candles: openArray[Candle]): string
• candle_graphs: proc plotCandles(candles: openArray[Candle]; options: CandlePlotOptions): string
• candle_graphs: proc plotCandles(labels: openArray[string]; candles: openArray[Candle]): string
• candle_graphs: proc plotCandles(labels: openArray[string]; candles: openArray[Candle]; options: CandlePlotOptions): string

plotContour:

• surface_graphs: proc plotContour[T: SomeNumber](data: openArray[seq[T]]): string
• surface_graphs: proc plotContour[T: SomeNumber](data: openArray[seq[T]]; options: SurfacePlotOptions): string
• surface_graphs: proc plotContour[T: SomeNumber](data: openArray[T]; columns: int): string
• surface_graphs: proc plotContour[T: SomeNumber](data: openArray[T]; columns: int; options: SurfacePlotOptions): string

plotMany:

• line_graphs: proc plotMany[T: SomeNumber](data: openArray[seq[T]]; config: AsciiGraphConfig): string
• line_graphs: proc plotMany[T: SomeNumber](data: openArray[seq[T]]; options: varargs[LineGraphOption]): string

plotScatter:

• xy_graphs: proc plotScatter[X, Y: SomeNumber](xValues: openArray[X]; yValues: openArray[Y]): string
• xy_graphs: proc plotScatter[X, Y: SomeNumber](xValues: openArray[X]; yValues: openArray[Y]; options: XYPlotOptions): string
• xy_graphs: proc plotScatter(points: openArray[XYPoint]): string
• xy_graphs: proc plotScatter(points: openArray[XYPoint]; options: XYPlotOptions): string

plotScatterMany:

• xy_graphs: proc plotScatterMany(series: openArray[XYSeries]): string
• xy_graphs: proc plotScatterMany(series: openArray[XYSeries]; options: XYPlotOptions): string

PlotStyle:

• static_graphs: enum PlotStyle

plotSurface:

• surface_graphs: proc plotSurface[T: SomeNumber](data: openArray[seq[T]]): string
• surface_graphs: proc plotSurface[T: SomeNumber](data: openArray[seq[T]]; options: SurfacePlotOptions): string
• surface_graphs: proc plotSurface[T: SomeNumber](data: openArray[T]; columns: int): string
• surface_graphs: proc plotSurface[T: SomeNumber](data: openArray[T]; columns: int; options: SurfacePlotOptions): string

Plotter:

• static_graphs: object Plotter

plotXY:

• xy_graphs: proc plotXY[X, Y: SomeNumber](xValues: openArray[X]; yValues: openArray[Y]): string
• xy_graphs: proc plotXY[X, Y: SomeNumber](xValues: openArray[X]; yValues: openArray[Y]; options: XYPlotOptions): string
• xy_graphs: proc plotXY(points: openArray[XYPoint]): string
• xy_graphs: proc plotXY(points: openArray[XYPoint]; options: XYPlotOptions): string

plotXYMany:

• xy_graphs: proc plotXYMany(series: openArray[XYSeries]): string
• xy_graphs: proc plotXYMany(series: openArray[XYSeries]; options: XYPlotOptions): string

psFill:

• static_graphs: PlotStyle.psFill

psLine:

• static_graphs: PlotStyle.psLine

push:

• live_graphs: proc push(graph: var LiveCandleGraph; value: Candle)
• live_graphs: proc push(graph: var LiveCandleGraph; value: Candle; label: string)
• live_graphs: proc push(graph: var LiveCandleGraph; values: openArray[Candle])
• live_graphs: proc push(graph: var LiveCandleGraph; labels: openArray[string]; values: openArray[Candle])
• live_graphs: proc push(graph: var LiveGraph; seriesIdx: int; value: float64)
• live_graphs: proc push(graph: var LiveGraph; seriesIdx: int; values: openArray[float64])
• live_graphs: proc push(graph: var LiveLineGraph; seriesIdx: int; value: float64)
• live_graphs: proc push(graph: var LiveLineGraph; seriesIdx: int; values: openArray[float64])
• static_graphs: proc push(plotter: var Plotter; seriesIdx: int; value: float64)
• static_graphs: proc push(plotter: var Plotter; seriesIdx: int; values: openArray[float64])

render:

• static_graphs: proc render(plotter: Plotter; width = 0; height = 0; useColor = true; showStats = true): string

renderFrame:

• live_graphs: proc renderFrame(graph: LiveCandleGraph): string
• live_graphs: proc renderFrame(graph: LiveGraph): string
• live_graphs: proc renderFrame(graph: LiveLineGraph): string

replaceLinesSequence:

• line_graphs: proc replaceLinesSequence(frame: string; previousLineCount: int): string

sampleCount:

• live_graphs: proc sampleCount(graph: LiveLineGraph; seriesIdx: int): int
• static_graphs: proc sampleCount(plotter: Plotter; seriesIdx: int): int

samples:

• static_graphs: proc samples(plotter: Plotter; seriesIdx: int): seq[float64]

scmLowest:

• sparkline_graphs: SparklineConstantMode.scmLowest

scmMiddle:

• sparkline_graphs: SparklineConstantMode.scmMiddle

Series:

• static_graphs: object Series

seriesCount:

• static_graphs: proc seriesCount(plotter: Plotter): int

SeriesStats:

• static_graphs: object SeriesStats

setBarRange:

• bar_graphs: proc setBarRange(options: var BarGraphOptions; minimum, maximum: float64)

setCandleRange:

• candle_graphs: proc setCandleRange(options: var CandlePlotOptions; minimum, maximum: float64)

setMaxSamples:

• static_graphs: proc setMaxSamples(plotter: var Plotter; maxSamples: int)

setRange:

• live_graphs: proc setRange(graph: var LiveCandleGraph; minimum, maximum: float64)
• live_graphs: proc setRange(graph: var LiveGraph; minimum, maximum: float64)
• static_graphs: proc setRange(plotter: var Plotter; minimum, maximum: float64)

setSparklineMaximum:

• sparkline_graphs: proc setSparklineMaximum(options: var SparklineOptions; maximum: float64)

setSparklineMinimum:

• sparkline_graphs: proc setSparklineMinimum(options: var SparklineOptions; minimum: float64)

setSparklineRange:

• sparkline_graphs: proc setSparklineRange(options: var SparklineOptions; minimum, maximum: float64)

setSurfaceRange:

• surface_graphs: proc setSurfaceRange(options: var SurfacePlotOptions; minimum, maximum: float64)

setXRange:

• xy_graphs: proc setXRange(options: var XYPlotOptions; minimum, maximum: float64)

setYRange:

• xy_graphs: proc setYRange(options: var XYPlotOptions; minimum, maximum: float64)

sparkline:

• sparkline_graphs: proc sparkline[T: SomeNumber](data: openArray[T]): string
• sparkline_graphs: proc sparkline[T: SomeNumber](data: openArray[T]; rawOptions: SparklineOptions): string

SparklineConstantMode:

• sparkline_graphs: enum SparklineConstantMode

SparklineOptions:

• sparkline_graphs: object SparklineOptions

SparklineTicks:

• sparkline_graphs: const SparklineTicks

startLive:

• live_graphs: proc startLive(graph: var LiveCandleGraph; clearScreen = true)
• live_graphs: proc startLive(dashboard: var LiveDashboard)
• live_graphs: proc startLive(graph: var LiveGraph; clearScreen = true)
• live_graphs: proc startLive(graph: var LiveLineGraph; clearScreen = true)

StaticGraph:

• static_graphs: type StaticGraph

statistics:

• static_graphs: proc statistics(plotter: Plotter; seriesIdx: int): Option[SeriesStats]

stopLive:

• live_graphs: proc stopLive(graph: var LiveCandleGraph)
• live_graphs: proc stopLive(dashboard: var LiveDashboard)
• live_graphs: proc stopLive(graph: var LiveGraph)
• live_graphs: proc stopLive(graph: var LiveLineGraph)

SurfaceGlyphs:

• surface_graphs: const SurfaceGlyphs

SurfacePlotOptions:

• surface_graphs: object SurfacePlotOptions

synchronizedOutputSequence:

• line_graphs: proc synchronizedOutputSequence(update: string): string

updateLatest:

• live_graphs: proc updateLatest(graph: var LiveCandleGraph; value: Candle)
• live_graphs: proc updateLatest(graph: var LiveCandleGraph; value: Candle; label: string)

upperBound:

• line_graphs: proc upperBound(value: float64): LineGraphOption

valueRange:

• static_graphs: proc valueRange(plotter: Plotter): tuple[minimum, maximum: float64]

XYPlotOptions:

• xy_graphs: object XYPlotOptions

XYPoint:

• xy_graphs: object XYPoint

xyPoint:

• xy_graphs: proc xyPoint[X, Y: SomeNumber](x: X; y: Y): XYPoint

xyPoints:

• xy_graphs: proc xyPoints[X, Y: SomeNumber](xValues: openArray[X]; yValues: openArray[Y]): seq[ XYPoint]

XYSeries:

• xy_graphs: object XYSeries