创建具有可变逻辑和可变变量计数的 C# 算法

Question

I'm messing around with creating a trading "bot" for personal use and am trying to create a form to control the signals that are used, but am having trouble working out how to correctly process the data based on my form inputs because the logic to apply to the variables needs to be selected by the form, eg:

In the screenshot above, I am using a basic algorithm which says:

Buy If 
    StochRSI < 20
        **AND** 
    (MACD is crossing on rise **OR** Awesome Oscillator Signals Buy) 
        **AND** 
    Hurst Exponent > 0.5

However, in this setup

I am saying:

Buy If 
    (RSI < 30 **OR** StochRSI < 20) 
        **AND** 
    (MACD is crossing on rise **OR** Awesome Oscillator Signals Buy) 
        **AND** 
    Hurst Exponent > 0.5

The difference is only that I have added in the RSI indicator, but note that I might have wanted to use both RSI and StochRSI and write this:

Buy If 
    RSI < 30 
        **AND** 
    StochRSI < 20
        **AND** 
    (MACD is crossing on rise **OR** Awesome Oscillator Signals Buy) 
        **AND** 
    Hurst Exponent > 0.5 

NOTE the brackets around the OR statements

This form is submitting via AJAX to a server side method which processes the data and creates the charts and signals, the problem is that I can't figure out how to take the inputs and make a formula which correctly puts the OR operators into bracketed equations optionally according to the correct variables submitted by the form.

I have tried processing all the OR options first, but that's not using the right sequences. I am quite close using a setup in which I first list all the variables and incrementally check the logic required for the next signal and process, but that isn't always right.

My method is currently writing this for the above example:

Buy If 
    RSI < 30 
        **AND** 
    StochRSI < 20
        **AND** 
    MACD is crossing on rise
        **OR** 
    Awesome Oscillator Signals Buy
        **AND** 
    Hurst Exponent > 0.5 

Unless I am very much mistaken, this is close but not quite the correct formula (not brackets for the OR)

Additionally, I want to be able to add indicators to this and ideally not have to write millions of lines of code to add them....

EDIT:

OK, so this question was closed due to lack of information, so I will try to improve...

The aims are identified above. I have created an "alogorithm" class which is serialised from the form fields in the screenshot and would create a set of values like this:

BuyAlgorithm: 
    awesomeFollowingLogic: AND 
    hurstFollowingLogic: OR
    macdFollowingLogic: OR
    rsiFollowingLogic: AND
    stochRsiFollowingLogic: AND 
    useAwesomeTriggers: false
    useHurstExponent: true
    useMACDTriggers: true
    useRsiTriggers: false
    useStochRsiTriggers: false

Given a series of signals derived from the market data, such as:

Signals:
    RSIsignal:               Buy/Ignore
    StochRSIsignal:          Buy/Ignore
    MACDSignal:              Buy/Ignore
    AwesomeOscillatorSignal: Buy/Ignore
    HurstExponentSignal:     Buy/Ignore

How can I take the variables above and use the logic defined by the properties such as rsiFollowingLogic etc to generate a Buy/Ignore signal ignoring those which are not to be taken into account, and compounding the formula correctly to use the OR AND and ANDNOT without writing millions of lines!!

Answer 1

Thanks for all the help, I managed to solve it myself with a JSFiddle which I have re-worked for C# in my main project.

For those interested, this is a drag and drop basic algorithm builder:

https://jsfiddle.net/jhartnoll/ozeqv86w/

The algorithm is basically a list of indicators like this:

[
  [
    [
      "macd",
      "hurst"
    ],
    [
      "rsi"
    ]
  ]
]

The code to determine true/false based on an input of Buy or Sell is

function confirmAction(algorithm, indicators, side) {
  let algoSteps = []; // new List<bool>();
  algorithm.forEach(function(outerList) {
    let algoRows = []; //new List<bool>();
    outerList.forEach(function(innerList) {
      // check each row of the algorithm (this is an OR list, so set true if ANY of these are true) and add the row result to the rows list. 
      algoRows.push(innerList.filter(i => indicators[i] && indicators[i] == side).length > 0);
    });
    // this step should return true only if ALL the rows are true (each row is an AND operator whilst the values within the row are an OR operator) 
    algoSteps.push(algoRows.filter(i => !i).length == 0);
  });
  // now finally, return true if any of the steps are true, steps are an OR operator.
  // It would be quite simple to toggle this final step to be AND if required...?
  return algoSteps.filter(i => i).length > 0;
}

I have commented each stage to hopefully explain what the list iteration is doing.

This takes in input which is an object showing the "decisions" each indicator makes like this:

{
  "rsi": "hold",
  "stoch": "hold",
  "macd": "sell",
  "ao": "hold",
  "hurst": "sell"
}

Yes I know this isn't the best collection of indicators to use, it's just for testing the concept of developing the extendable algorithm. The number of indicators input into this can be as many or as few as required.

Obviously the actual buy/sell indicators are generated in separate code, but for this example and testing in the JSFiddle you can simply set them in the top section of the fiddle to test the algo.