Calculate Commodity Channel Index (CCI) Using Haskell?

The Commodity Channel Index (CCI) is a popular technical indicator used to identify overbought or oversold conditions in a market. It is calculated by taking the difference between the typical price of a security for a specified period and a simple moving average of the typical price, and then dividing that difference by a normalized mean deviation.

To calculate the CCI using Haskell, you would first need to define functions to calculate the typical price, the simple moving average, and the mean deviation. You would then use these functions to calculate the CCI for each data point in your dataset.

Here is an example of how you might implement a function to calculate the CCI in Haskell:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

calculateCCI :: [Double] -> Int -> Int -> [Double]
calculateCCI prices period = 
  let tp = map (\(h,l,c) -> (h + l + c) / 3) prices
      sma = map (sma prices period) [0 .. length prices - 1 - period]
      meanDev = map (meanDev tp sma period) [0 .. length tp - 1 - period]
  in zipWith3 (\tp' sma' md -> (tp' - sma') / (0.015 * md)) tp sma meanDev

sma :: [Double] -> Int -> Int -> Double
sma prices period n = sum (take period (drop n prices)) / fromIntegral period

meanDev :: [Double] -> [Double] -> Int -> Int -> Double
meanDev tp sma period n = sum (take period (drop n (map (\(tp', sma') -> abs (tp' - sma')) (zip tp sma)))) / fromIntegral period

This code defines a function calculateCCI that takes a list of price data, a period length for the CCI calculation, and a period length for the simple moving average. It calculates the CCI for each data point in the input list and returns a list of CCI values.

You would need to provide your price data as a list of tuples (high, low, close) and call the calculateCCI function with the appropriate period lengths to calculate the CCI for your dataset.

Best Trading Sites for Beginners & Experts in 2024

1

Rating is 5 out of 5

FinViz

Try It Now

2

Rating is 4.9 out of 5

TradingView

Try It Now

3

Rating is 4.8 out of 5

FinQuota

Try It Now

4

Rating is 4.7 out of 5

Yahoo Finance

Try It Now

What is the purpose of using Commodity Channel Index (CCI) in trading strategies?

The Commodity Channel Index (CCI) is used in trading strategies to identify potential overbought or oversold conditions in a market. It helps traders determine when a market is reaching extreme levels and may be due for a reversal. Traders can use the CCI to help identify entry and exit points for trades, as well as to confirm trends and momentum in a market. Overall, the purpose of using the CCI in trading strategies is to help traders make more informed decisions and improve the accuracy of their trading signals.

How to backtest a trading strategy using Commodity Channel Index (CCI) in Haskell?

To backtest a trading strategy using the Commodity Channel Index (CCI) in Haskell, you can follow these steps:

1. Implement the CCI calculation function:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

cci :: Int -> [Double] -> [Double]
cci period prices = do
    let typicalPrices = map (\(h,l,c) -> (h + l + c) / 3) $ zip3 (drop (period-1) highs) (drop (period-1) lows) (drop (period-1) closes)
    let meanDev = mean typicalPrices
    let meanDeviation = map (\typPrice -> abs(typPrice - meanDev)) typicalPrices
    let meanDeviationAvg = [sum (take period meanDeviation) / fromIntegral period]
    let cciValues = zipWith3 (\tp md mdav -> (tp - md) / (0.015 * mdav)) typicalPrices meanDeviation meanDeviationAvg
    replicate (period-1) 0 ++ cciValues
    where
        highs = map (\(h, _, _) -> h) prices
        lows = map (\(_, l, _) -> l) prices
        closes = map (\(_, _, c) -> c) prices
        mean xs = sum xs / genericLength xs

1. Write the buy/sell signal generation logic based on the CCI value:

1
2

generateSignals :: [Double] -> [Int]
generateSignals cciValues = map (\cci -> if cci > 100 then -1 else if cci < -100 then 1 else 0) cciValues

1. Implement the backtesting function to calculate the PnL (profit and loss) of the strategy:

1
2

backtest :: [Double] -> [Int] -> [Double] -> Double
backtest prices signals trades = sum $ zipWith3 (\p s t -> p * fromIntegral s * t) prices signals trades

1. Finally, combine these functions to test a trading strategy using CCI:

1
2
3
4
5
6
7
8

main :: IO ()
main = do
    let prices = [100.0, 105.0, 110.0, 115.0, 120.0, 125.0, 130.0, 135.0, 140.0, 145.0]
    let cciValues = cci 5 prices
    let signals = generateSignals cciValues
    let trades = [1,1,-1,-1,-1,1,1,-1,1,-1]
    let pnl = backtest prices signals trades
    putStrLn $ "Final PnL: " ++ show pnl

This example demonstrates how you can implement and test a trading strategy using the Commodity Channel Index (CCI) in Haskell. You can further optimize and customize the strategy based on your specific requirements and market conditions.

How to define a function in Haskell to calculate Commodity Channel Index (CCI)?

Here is an example of how you can define a function in Haskell to calculate the Commodity Channel Index (CCI):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

-- Import required modules
import Data.List (genericTake)

-- Function to calculate CCI
cci :: Int -> [Double] -> Double
cci n xs = let tp = [(x + y + z) / 3 | (x, y, z) <- zip3 xs (genericTake n (drop 1 xs)) (genericTake n (drop 2 xs))]
               sma = sum (take n tp) / fromIntegral n
               meanDev = sum (map (\x -> abs (x - sma)) tp) / fromIntegral n
               cci = (head tp - sma) / (0.015 * meanDev)
           in cci

In this implementation, the cci function takes two arguments: n as the period for the CCI calculation and a list of prices xs. It calculates the typical price (tp), simple moving average (sma), mean deviation and finally the CCI value using these values.

You can call this function with a specified period n and a list of prices to calculate the CCI value.

How to plot Commodity Channel Index (CCI) alongside price data in Haskell?

To plot the Commodity Channel Index (CCI) alongside price data in Haskell, you can use a library like Chart or diagrams. Here is a simple example using Chart library:

1. First, you need to install the Chart library by adding it to your project's dependencies in your stack.yaml file:

1
2

dependencies:
  - Chart

1. Import the necessary modules in your Haskell script:

1
2
3
4
5
6

import Graphics.Rendering.Chart.Easy
import Graphics.Rendering.Chart.Backend.Diagrams
import Data.Colour
import Data.Colour.SRGB
import Data.Colour.Names
import Data.Default.Class

1. Define a function to calculate the CCI values:

1
2
3
4
5
6
7
8
9

cci :: [Double] -> Int -> [Double]
cci prices period = do
    let tp = map (\x -> (x!!0 + x!!1 + x!!2 ) / 3.0) $ chunksOf 3 prices
    let sma :: [Double] -> Int -> [Double]
        sma xs n = zipWith (/) (scanl (+) 0 xs) $ map fromIntegral [1..n] ++ repeat (fromIntegral n)
    let mean = sma tp period
    let deviation = zipWith (\p m -> abs (p - m)) tp mean
    let md = sma deviation period
    zipWith3 (\p m d -> (p - m) / (d * 0.015)) tp mean md

1. Define a function to plot the CCI and price data:

1
2
3
4
5
6
7
8

plotCCI :: [Double] -> Int -> IO ()
plotCCI prices period = toFile def "cci_price_plot.svg" $ do
    layout_title .= "CCI and Price Data"
    setColors [opaque blue, opaque red]
    plot (line "Price" [map (\x -> (x, 0)) $ take (length prices) [0..] `zip` prices])
    plot (line "CCI" [map (\x -> (x, 0)) $ take (length cciValues) [0..] `zip` cciValues])
  where
    cciValues = cci prices period

1. Finally, call the plotCCI function with your price data and CCI period:

1
2
3
4
5

main :: IO ()
main = do
    let prices = [100.0, 105.0, 110.0, 108.0, 115.0, 120.0, 125.0, 130.0, 127.0, 125.0]
    let period = 5
    plotCCI prices period

This code will generate a plot with both the price data and the Commodity Channel Index (CCI) values. You can customize the plot further by adjusting the layout, colors, and other parameters as needed.

What are some common variations of Commodity Channel Index (CCI) used by traders?

1. CCI with Moving Average: Traders often use a moving average in conjunction with CCI to smooth out the indicator and generate more accurate signals.
2. Double CCI: This variation involves using two CCIs with different time periods in order to cross-reference signals and confirm trends.
3. CCI Divergence: Traders look for divergences between the price action and the CCI indicator, which can signal a potential reversal in the trend.
4. CCI Overbought/Oversold Levels: Traders may set specific overbought and oversold levels on the CCI indicator to help identify potential buying and selling opportunities.
5. Customized CCI Periods: Traders may experiment with different time periods for the CCI indicator to see which one works best for their trading style and preferences.

What is the role of trend analysis in conjunction with Commodity Channel Index (CCI)?

Trend analysis plays a crucial role in conjunction with the Commodity Channel Index (CCI) as it helps traders identify the direction of the price trend and potential reversal points in the market. The CCI is a momentum oscillator that is used to gauge the strength and direction of a trend, as well as to identify overbought or oversold conditions in the market.

By conducting trend analysis along with the CCI, traders can confirm signals provided by the CCI and make more informed trading decisions. For example, if the CCI indicates that a security is overbought, traders can look for confirmation through trend analysis to see if the price is indeed in an uptrend and if a potential reversal is likely.

Overall, trend analysis helps traders understand the broader market context in which the CCI signals are being generated and can provide valuable insights into future price movements. It is important to use trend analysis in conjunction with the CCI to increase the accuracy of trading signals and improve overall performance in the market.