Skip to content

MoneyFlowIndex

Summary

The Money Flow Index is an oscillator that calculates buying and selling pressure using typical price and volume. It oscillates between zero and one hundred. It is typically used to identify trend reversals and price extremes.

Signature 

1
public abstract interface MoneyFlowIndex

Namespace

cAlgo.API.Indicators

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
 private MoneyFlowIndex _moneyFlow;
 [Parameter("Period", DefaultValue = 14)]
 public int Period { get; set; }
 [Output("Main")]
 public IndicatorDataSeries Result { get; set; }
 protected override void Initialize()
 {
    _moneyFlow = Indicators.MoneyFlowIndex(Period);
 }
 public override void Calculate(int index)
 {
    // Display Result of Indicator
    Result[index] = _moneyFlow.Result[index];
 }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 using cAlgo.API;
 using cAlgo.API.Indicators;
 namespace cAlgo.Robots
 {
     // This sample cBot shows how to use the Money Flow Index indicator
     [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
     public class MoneyFlowIndexSample : Robot
     {
         private double _volumeInUnits;
         private MoneyFlowIndex _moneyFlowIndex;
         [Parameter("Volume (Lots)", DefaultValue = 0.01)]
         public double VolumeInLots { get; set; }
         [Parameter("Stop Loss (Pips)", DefaultValue = 10)]
         public double StopLossInPips { get; set; }
         [Parameter("Take Profit (Pips)", DefaultValue = 10)]
         public double TakeProfitInPips { get; set; }
         [Parameter("Label", DefaultValue = "Sample")]
         public string Label { get; set; }
         public Position[] BotPositions
         {
             get
             {
                 return Positions.FindAll(Label);
             }
         }
         protected override void OnStart()
         {
             _volumeInUnits = Symbol.QuantityToVolumeInUnits(VolumeInLots);
             _moneyFlowIndex = Indicators.MoneyFlowIndex(14);
         }
         protected override void OnBar()
         {
             if (_moneyFlowIndex.Result.Last(1) > 80)
             {
                 ClosePositions(TradeType.Buy);
                 if (BotPositions.Length == 0)
                 {
                     ExecuteMarketOrder(TradeType.Sell, SymbolName, _volumeInUnits, Label, StopLossInPips, TakeProfitInPips);
                 }
             }
             else if (_moneyFlowIndex.Result.Last(1) < 20)
             {
                 ClosePositions(TradeType.Sell);
                 if (BotPositions.Length == 0)
                 {
                     ExecuteMarketOrder(TradeType.Buy, SymbolName, _volumeInUnits, Label, StopLossInPips, TakeProfitInPips);
                 }
             }
         }
         private void ClosePositions(TradeType tradeType)
         {
             foreach (var position in BotPositions)
             {
                 if (position.TradeType != tradeType) continue;
                 ClosePosition(position);
             }
         }
     }
 }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
 import clr
 clr.AddReference("cAlgo.API")
 from cAlgo.API import *
 class Test():    
     def initialize(self):
         # Periods is a parameter defined in C# file of indicator
         self.moneyFlowIndex = api.Indicators.MoneyFlowIndex(api.Periods)
     def calculate(self, index):
         # Result is an indicator output defined in C# file of indicator
         # Display Result of Indicator
         api.Result[index] = self.moneyFlowIndex.Result[index]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 import clr
 clr.AddReference("cAlgo.API")
 # Import cAlgo API types
 from cAlgo.API import *
 # Import trading wrapper functions
 from robot_wrapper import *
 class MoneyFlowIndexSample():
     def on_start(self):
         self.volumeInUnits = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
         self.moneyFlowIndex = api.Indicators.MoneyFlowIndex(api.Periods)
     def on_bar_closed(self):
         if self.moneyFlowIndex.Result.Last(0) > api.LevelUp:
             self.close_positions(TradeType.Sell)
             if len(self.get_bot_positions()) == 0:
                 api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, self.volumeInUnits, api.Label, api.StopLossInPips, api.TakeProfitInPips)
         elif self.moneyFlowIndex.Result.Last(0) < api.LevelDown:
             self.close_positions(TradeType.Buy)
             if len(self.get_bot_positions()) == 0:
                 api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, self.volumeInUnits, api.Label, api.StopLossInPips, api.TakeProfitInPips)
     def get_bot_positions(self):
         return api.Positions.FindAll(api.Label)
     def close_positions(self, tradeType):
         for position in self.get_bot_positions():
             if position.TradeType != tradeType:
                 continue
             api.ClosePosition(position)

Properties

Result

Summary

The time series of the Money Flow Index indicator.

Signature 

1
public abstract IndicatorDataSeries Result {get; set;}

Return Value

IndicatorDataSeries

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
 private MoneyFlowIndex _moneyFlow;
 [Parameter("Period", DefaultValue = 21)]
 public int Period { get; set; }
 protected override void OnStart()
 {
     _moneyFlow = Indicators.MoneyFlowIndex(Period);
 }
 protected override void OnBar()
 {
     var currentValue = _moneyFlow.Result.LastValue;
     //...
 }

1
2
3
4
5
6
7
8
9
 import clr
 clr.AddReference("cAlgo.API")
 from cAlgo.API import *
 class Test():    
     def initialize(self):
         # Periods is a parameter defined in C# file of indicator
         self.moneyFlowIndex = api.Indicators.MoneyFlowIndex(api.Periods)
     def calculate(self, index):
         currentValue = self.moneyFlowIndex.Result.LastValue