# Bollinger Bands Implementation in BanTA: Complete Developer Guide

> Find the Bollinger Bands implementation in BanTA within the Go and Python files. This developer guide provides the exact locations for core logic and public APIs.

- Repository: [banbox/banta](https://github.com/banbox/banta)
- Tags: how-to-guide
- Published: 2026-02-26

---

**The Bollinger Bands implementation in BanTA is located in [`sta_inds.go`](https://github.com/banbox/banta/blob/main/sta_inds.go) for core series-based logic, [`tav/indicators.go`](https://github.com/banbox/banta/blob/main/tav/indicators.go) for slice-based public APIs, and [`python/tav/index.go`](https://github.com/banbox/banta/blob/main/python/tav/index.go) plus [`python/ta/index.go`](https://github.com/banbox/banta/blob/main/python/ta/index.go) for Python bindings.**

The BanTA library (`banbox/banta`) provides a comprehensive technical analysis toolkit for Go and Python developers. Understanding where the **Bollinger Bands in BanTA** implementation resides helps developers leverage this volatility indicator effectively across different data structures and programming languages.

## Core Implementation Files for Bollinger Bands in BanTA

### Series-Based Core Logic (sta_inds.go)

The foundational implementation operates on BanTA's internal `Series` type. In [`sta_inds.go`](https://github.com/banbox/banta/blob/main/sta_inds.go) (around lines 861-877), the `BBANDS` function computes the upper, middle, and lower bands by first calling `StdDevBy` to obtain the moving average and standard deviation. It then applies the user-supplied multipliers `stdUp` and `stdDn` to generate the final band values.

### Slice-Based Public API (tav/indicators.go)

For developers working with raw Go slices, the slice-based implementation in [`tav/indicators.go`](https://github.com/banbox/banta/blob/main/tav/indicators.go) (lines 426-458) provides the public API. This function mirrors the series version's logic but accepts `[]float64` input directly. It calls `StdDevBy` to calculate rolling mean and standard deviation for the raw slice, then constructs three result slices (`upper`, `middle`, `lower`) representing the respective Bollinger Bands.

### Python Bindings (python/tav/index.go and python/ta/index.go)

BanTA exposes the same Bollinger Bands logic to Python through CGO wrappers. The file [`python/tav/index.go`](https://github.com/banbox/banta/blob/main/python/tav/index.go) (lines 111-116) wraps the slice implementation for Python's `banta.tav` module, while [`python/ta/index.go`](https://github.com/banbox/banta/blob/main/python/ta/index.go) (lines 57-60) wraps the series implementation for the `banta.ta` module. These wrappers allow Python developers to call `BBANDS` with standard list or numpy-compatible inputs.

## How the Bollinger Bands Algorithm Works in BanTA

The implementation follows the standard Bollinger Bands formula. First, `StdDevBy` calculates the **simple moving average (SMA)** and **standard deviation** over the specified window. The middle band equals the SMA. The upper band adds the product of `stdUp` and the standard deviation to the SMA. The lower band subtracts the product of `stdDn` and the standard deviation from the SMA. This three-line approach captures volatility expansion and contraction dynamically.

## Code Examples: Using Bollinger Bands in BanTA

### Go: Series API

When working with BanTA's `Series` objects, use the core package directly:

```go
// prices is a *Series containing historical price data
upper, middle, lower := banta.BBANDS(prices, 20, 2.0, 2.0)
fmt.Println("Upper:", upper.Get(0), "Middle:", middle.Get(0), "Lower:", lower.Get(0))

```

### Go: Slice API

For raw float64 slices without the Series abstraction:

```go
data := []float64{101.2, 102.5, 100.8, 103.2, 101.5, 102.1, 100.9}
upper, middle, lower := banta.BBANDS(data, 20, 2.0, 2.0)
// Access the most recent values
fmt.Println(upper[len(upper)-1], middle[len(middle)-1], lower[len(lower)-1])

```

### Python

Import the `tav` module to access the slice-based implementation:

```python
import banta.tav as tav

prices = [101.2, 102.5, 100.8, 103.2, 101.5, 102.1, 100.9]
upper, middle, lower = tav.BBANDS(prices, 20, 2.0, 2.0)
print(f"Upper: {upper[-1]}, Middle: {middle[-1]}, Lower: {lower[-1]}")

```

## Summary

- The **Bollinger Bands in BanTA** implementation spans four key files: [`sta_inds.go`](https://github.com/banbox/banta/blob/main/sta_inds.go) for core `Series` logic, [`tav/indicators.go`](https://github.com/banbox/banta/blob/main/tav/indicators.go) for slice-based APIs, and two Python wrapper files.
- The algorithm uses `StdDevBy` to calculate moving averages and standard deviations, then applies configurable multipliers to generate upper, middle, and lower bands.
- Developers can access the indicator from Go using either `Series` objects or raw `[]float64` slices, and from Python through the `banta.tav` or `banta.ta` modules.

## Frequently Asked Questions

### What parameters does the BBANDS function accept in BanTA?

The `BBANDS` function accepts four parameters: the input data (`*Series` or `[]float64`), the lookback period (integer), the upper standard deviation multiplier (`stdUp` as float64), and the lower standard deviation multiplier (`stdDn` as float64). Typical values use a 20-period window with 2.0 for both multipliers.

### How does BanTA calculate the standard deviation for Bollinger Bands?

BanTA calculates standard deviation through the `StdDevBy` helper function, which computes both the simple moving average (SMA) and the standard deviation over the specified window. The middle band equals the SMA, while the upper and lower bands derive from adding or subtracting the product of the standard deviation and the respective multipliers.

### Can I use BanTA's Bollinger Bands with Python numpy arrays?

Yes, the Python bindings in [`python/tav/index.go`](https://github.com/banbox/banta/blob/main/python/tav/index.go) wrap the slice-based implementation, allowing you to pass Python lists or numpy arrays directly to the `BBANDS` function. The wrapper handles conversion between Python sequences and Go slices, returning three Python lists representing the upper, middle, and lower bands.

### What is the difference between the Series and slice implementations?

The **Series** implementation in [`sta_inds.go`](https://github.com/banbox/banta/blob/main/sta_inds.go) operates on BanTA's internal `*Series` type, which maintains state and supports method chaining within the library's core architecture. The **slice** implementation in [`tav/indicators.go`](https://github.com/banbox/banta/blob/main/tav/indicators.go) works with raw `[]float64` inputs, making it suitable for standalone use or external APIs that don't require the full Series abstraction.