What is the Midpoint Over Period (MIDPOINT)?

MIDPOINT computes the midpoint between the highest and lowest values over a lookback window: (max + min) / 2. It acts as a dynamic equilibrium line for a single input series.

How do I calculate the Midpoint Over Period (MIDPOINT)?

The Midpoint Over Period (MIDPOINT) is calculated using specific mathematical formulas with parameters: period (default: 14).

What are the best settings for Midpoint Over Period (MIDPOINT)?

The optimal settings depend on your trading style and timeframe. Default settings are: period: 14. Experiment with different values to find what works best for your strategy.

Midpoint Over Period (MIDPOINT)

Parameters: period = 14 (2–200)

Overview

MIDPOINT computes the center of the rolling range by tracking the highest and lowest values over the last period samples, then averaging them: (max + min) / 2. Because it responds immediately when a new high or low enters the window, it provides a simple, interpretable equilibrium line that adapts to volatility and range expansion.

Traders use MIDPOINT as a trend/mean‑reversion reference: price above the midpoint suggests strength within the recent range; price below suggests weakness. It’s also useful as a baseline series for other transforms and filters when you want range‑aware smoothing without EMA-style recursion.

Implementation Examples

Compute MIDPOINT from a slice or candles:

use vector_ta::indicators::midpoint::{midpoint, MidpointInput, MidpointParams};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let data: Vec<f64> = vec![/* ... */];
let input = MidpointInput::from_slice(&data, MidpointParams { period: Some(14) });
let out = midpoint(&input)?;

let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let input = MidpointInput::with_default_candles(&candles); // source="close", period=14
let out = midpoint(&input)?;

for v in out.values { println!("MIDPOINT: {}", v); }

Configure period and kernel selection:

use vector_ta::indicators::midpoint::MidpointBuilder;
use vector_ta::utilities::enums::Kernel;

let out = MidpointBuilder::new()
    .period(20)
    .kernel(Kernel::Auto)
    .apply_slice(&data)?;

let out = MidpointBuilder::new()
    .period(20)
    .kernel(Kernel::Avx2)
    .apply(&candles)?;

Warmup returns None until enough data is observed:

use vector_ta::indicators::midpoint::{MidpointParams, MidpointStream};

let mut stream = MidpointStream::try_new(MidpointParams { period: Some(14) })?;
for x in data_feed() {
    if let Some(v) = stream.update(x) {
        handle(v);
    }
}

Sweep period values efficiently:

use vector_ta::indicators::midpoint::MidpointBatchBuilder;
use vector_ta::utilities::enums::Kernel;

let out = MidpointBatchBuilder::new()
    .period_range(5, 30, 5)
    .kernel(Kernel::Auto)
    .apply_slice(&data)?;

println!("rows={}, cols={}", out.rows, out.cols);
// out.values is flat: rows*cols

Python Bindings

Quick Start ▼

import numpy as np
from vector_ta import midpoint, midpoint_batch, MidpointStream

data = np.asarray([...], dtype=np.float64)

values = midpoint(data, period=14, kernel=None)

stream = MidpointStream(period=14)
for x in data:
    v = stream.update(float(x))
    if v is not None:
        handle(v)

res = midpoint_batch(data, period_range=(5, 30, 5), kernel=None)
values_grid = res['values']

JavaScript/WASM Bindings

Basic Usage ▼

import { midpoint_js, midpoint_batch } from 'vectorta-wasm';

const data = new Float64Array(loadData());
const values = midpoint_js(data, 14);

const out = midpoint_batch(data, { period_range: [5, 30, 5] });
console.log(out.rows, out.cols);

Memory-Efficient Operations ▼

import { midpoint_alloc, midpoint_free, midpoint_into, memory } from 'vectorta-wasm';

const len = data.length;
const inPtr = midpoint_alloc(len);
const outPtr = midpoint_alloc(len);

new Float64Array(memory.buffer, inPtr, len).set(data);
midpoint_into(inPtr, outPtr, len, 14);
const values = new Float64Array(memory.buffer, outPtr, len).slice();

midpoint_free(inPtr, len);
midpoint_free(outPtr, len);

CUDA Bindings (Rust)

No Rust CUDA bindings are currently available for "midpoint".

Performance Analysis

Comparison:

View:

Loading chart...

AMD Ryzen 9 9950X (CPU) | NVIDIA RTX 4090 (GPU) | Benchmarks: 2026-01-08

Related Indicators

Average Directional Index

Technical analysis indicator

Average Directional Movement Index Rating

Technical analysis indicator

Alligator

Technical analysis indicator

Aroon

Technical analysis indicator

Aroon Oscillator

Technical analysis indicator

Chande Momentum Oscillator

Technical analysis indicator