From 278c9659ba299840e696cf29d3fcd7e67760c475 Mon Sep 17 00:00:00 2001 From: "ubuntu18.04" Date: Tue, 23 Mar 2021 07:42:53 -0700 Subject: [PATCH] position sizing --- src/main/java/or/model/ModelI.java | 5 -- src/main/java/or/model/SMASJeneticModel.java | 85 +++++++++++++++++++ src/main/java/or/model/SSMASJeneticModel.java | 43 ++++++++++ .../model/StrategyJeneticModelAbstract.java | 32 +++++++ src/main/java/or/model/StrategyModel.java | 48 ----------- .../java/or/model/TestJeneticsSolver.java | 80 +++++++++++++++++ src/main/java/or/solver/GridSearch.java | 14 --- src/main/java/or/solver/Jenetics.java | 75 ++++++++++++++++ src/main/java/or/solver/SolverI.java | 7 +- ...DualExpMovingAverageCrossoverStrategy.java | 69 +++++++++++---- .../DualMovingAverageCrossoverStrategy.java | 23 +++-- ...lSimpleMovingAverageCrossoverStrategy.java | 58 ++++++++++++- .../SingleExpMovingAverageStrategy.java | 42 +++++---- .../SingleMovingAverageCrossoverStrategy.java | 26 +++--- .../SingleSimpleMovingAverageStrategy.java | 47 ++++++---- .../strategies/StrategiesAnnotations.java | 2 +- .../java/strategies/StrategyAbstract.java | 23 ++++- src/main/java/strategies/StrategyI.java | 3 + ...ipleExpMovingAverageCrossoverStrategy.java | 85 +++++++++++++------ .../TripleMovingAverageCrossoverStrategy.java | 22 +++-- ...eSimpleMovingAverageCrossoverStrategy.java | 84 ++++++++++++------ .../positionsizing/FixedMoneyAmount.java | 42 +++++++++ .../positionsizing/PositionSizingI.java | 16 ++++ .../external/database/TestInfluxdb.java | 4 +- src/test/java/or/solver/TestSolver.java | 56 ++++++++++++ src/test/java/strategies/TestStrategies.java | 8 +- 26 files changed, 792 insertions(+), 207 deletions(-) create mode 100644 src/main/java/or/model/SMASJeneticModel.java create mode 100644 src/main/java/or/model/SSMASJeneticModel.java create mode 100644 src/main/java/or/model/StrategyJeneticModelAbstract.java delete mode 100644 src/main/java/or/model/StrategyModel.java create mode 100644 src/main/java/or/model/TestJeneticsSolver.java delete mode 100644 src/main/java/or/solver/GridSearch.java create mode 100644 src/main/java/or/solver/Jenetics.java create mode 100644 src/main/java/strategies/positionsizing/FixedMoneyAmount.java create mode 100644 src/main/java/strategies/positionsizing/PositionSizingI.java create mode 100644 src/test/java/or/solver/TestSolver.java diff --git a/src/main/java/or/model/ModelI.java b/src/main/java/or/model/ModelI.java index a86e437..e489fe4 100644 --- a/src/main/java/or/model/ModelI.java +++ b/src/main/java/or/model/ModelI.java @@ -3,15 +3,10 @@ */ package or.model; -import java.util.List; - /** * @author stefanopenazzi * */ public interface ModelI { - public List getObjectiveFunctionValues(Object...objects); - - } diff --git a/src/main/java/or/model/SMASJeneticModel.java b/src/main/java/or/model/SMASJeneticModel.java new file mode 100644 index 0000000..0f37b85 --- /dev/null +++ b/src/main/java/or/model/SMASJeneticModel.java @@ -0,0 +1,85 @@ +/** + * + */ +package or.model; + +import java.lang.reflect.InvocationTargetException; +import java.util.function.Function; + +import data.source.internal.timeseries.TimeSeriesI; +import io.jenetics.Chromosome; +import io.jenetics.Genotype; +import io.jenetics.IntegerChromosome; +import io.jenetics.IntegerGene; +import io.jenetics.Phenotype; +import io.jenetics.engine.Constraint; +import strategies.SingleMovingAverageCrossoverStrategy; + +/** + * @author stefanopenazzi + * + */ +public abstract class SMASJeneticModel extends StrategyJeneticModelAbstract { + + private TimeSeriesI ts; + + public SMASJeneticModel(Class strategyC,TimeSeriesI ts) { + super(strategyC); + this.ts = ts; + } + + @SuppressWarnings("rawtypes") + @Override + public Function getFitnessFunction() { + + Function res = gt -> { + IntegerChromosome length = (IntegerChromosome)gt.get(0); + T strategy = null; + try { + strategy = (T) this.strategyC.getConstructor(TimeSeriesI.class,String.class,Integer.TYPE,Integer.TYPE).newInstance(this.ts,"close",length.intValue(),0); + } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException + | NoSuchMethodException | SecurityException e) { + e.printStackTrace(); + } + strategy.run(); + return fitnessFunctionDesign(strategy); + + }; + return res; + } + + @SuppressWarnings("rawtypes") + public abstract Boolean isValid(final Genotype gt); + + @SuppressWarnings("rawtypes") + public abstract Genotype repairGenotype(final Genotype gt); + + public abstract double fitnessFunctionDesign(T smacs); + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public Genotype getEncoding() { + return Genotype.of((Chromosome)IntegerChromosome.of(1, 150, 1)); + } + + @SuppressWarnings("unchecked") + @Override + public Constraint getConstraint(){ + return new RepairingConstraint(); + } + + @SuppressWarnings("rawtypes") + private class RepairingConstraint implements Constraint{ + + @Override + public boolean test(Phenotype pt) { + return isValid(pt.genotype()); + } + + @Override + public Phenotype repair(Phenotype pt, long generation) { + return Phenotype.of(repairGenotype(pt.genotype()),generation); + } + + } +} diff --git a/src/main/java/or/model/SSMASJeneticModel.java b/src/main/java/or/model/SSMASJeneticModel.java new file mode 100644 index 0000000..bfbda20 --- /dev/null +++ b/src/main/java/or/model/SSMASJeneticModel.java @@ -0,0 +1,43 @@ +/** + * + */ +package or.model; + +import data.source.internal.timeseries.TimeSeriesI; +import io.jenetics.Genotype; +import io.jenetics.IntegerChromosome; +import io.jenetics.IntegerGene; +import strategies.SingleMovingAverageCrossoverStrategy; + +/** + * @author stefanopenazzi + * + */ +public class SSMASJeneticModel extends SMASJeneticModel { + + /** + * @param strategyC + * @param ts + */ + public SSMASJeneticModel(Class strategyC, TimeSeriesI ts) { + super(strategyC, ts); + } + + @Override + public double fitnessFunctionDesign(SingleMovingAverageCrossoverStrategy smacs) { + return smacs.getTotNetProfit(); + } + + @Override + public Boolean isValid(Genotype gt) { + return ((IntegerChromosome)gt.get(0)).intValue() > 0? true : false; + } + + @Override + public Genotype repairGenotype(Genotype gt) { + return Genotype.of(IntegerChromosome.of(1, 200, 1)); + } + + + +} diff --git a/src/main/java/or/model/StrategyJeneticModelAbstract.java b/src/main/java/or/model/StrategyJeneticModelAbstract.java new file mode 100644 index 0000000..4c20224 --- /dev/null +++ b/src/main/java/or/model/StrategyJeneticModelAbstract.java @@ -0,0 +1,32 @@ +/** + * + */ +package or.model; + +import java.util.function.Function; + +import io.jenetics.Genotype; +import io.jenetics.engine.Constraint; +import strategies.StrategyI; + +/** + * @author stefanopenazzi + * + */ +public abstract class StrategyJeneticModelAbstract implements ModelI { + + protected final Class strategyC; + + public StrategyJeneticModelAbstract(Class strategyC) { + this.strategyC = strategyC; + } + + @SuppressWarnings("rawtypes") + public abstract Function getFitnessFunction(); + + @SuppressWarnings("rawtypes") + public abstract Genotype getEncoding(); + + public abstract Constraint getConstraint(); + +} diff --git a/src/main/java/or/model/StrategyModel.java b/src/main/java/or/model/StrategyModel.java deleted file mode 100644 index 8fda957..0000000 --- a/src/main/java/or/model/StrategyModel.java +++ /dev/null @@ -1,48 +0,0 @@ -/** - * - */ -package or.model; - -import java.util.ArrayList; -import java.util.List; - -import strategies.StrategiesAnnotations.StrategyVariable; -import strategies.StrategyI; - -/** - * @author stefanopenazzi - * - */ -public class StrategyModel implements ModelI { - - private StrategyI strategy; - - @Override - public List getObjectiveFunctionValues(Object... objects){ - return null; - } - - public static final class Builder { - - private List stringConstraints = new ArrayList(); - private StrategyI strategy; - - public Builder(StrategyI strategy) { - this.strategy = strategy; - } - - public Builder addConstraint(StrategyVariable sv) { - this.stringConstraints.add(sv.name()); - return this; - } - - public StrategyModel build(){ - - StrategyModel strategyModel = new StrategyModel(); - strategyModel.strategy = this.strategy; - - return strategyModel; - } - } - -} diff --git a/src/main/java/or/model/TestJeneticsSolver.java b/src/main/java/or/model/TestJeneticsSolver.java new file mode 100644 index 0000000..e62e1f7 --- /dev/null +++ b/src/main/java/or/model/TestJeneticsSolver.java @@ -0,0 +1,80 @@ +/** + * + */ +package or.model; + +/** + * @author stefanopenazzi + * + */ + +import io.jenetics.BitChromosome; +import io.jenetics.BitGene; +import io.jenetics.Genotype; +import io.jenetics.RouletteWheelSelector; +import io.jenetics.TournamentSelector; +import io.jenetics.engine.Engine; +import io.jenetics.engine.EvolutionResult; +import io.jenetics.util.Factory; + +public class TestJeneticsSolver { + + // 2.) Definition of the fitness function. + private static Integer eval(Genotype gt) { + return gt.chromosome() + .as(BitChromosome.class) + .bitCount(); + } + + /** + * @param args + */ + public static void main(String[] args) { + // 1.) Define the genotype (factory) suitable + // for the problem. + + /* A chromosome is an array of Genes. A Genotype is an array of chromosome + * the chromosomes in the Genotype do not necessarily have the same size. + * Still unclear how this works considering that the genes are the variables of + * the model(a vector not a matrix). All the chromosomes must have the same genes' type */ + + Factory> gtf = + Genotype.of(BitChromosome.of(50, 0.5)); + + // 3.) Create the execution environment. + Engine engine = Engine + .builder(TestJeneticsSolver::eval, gtf) + //Selection for crossover and mutation follows + .survivorsSelector(new RouletteWheelSelector<>()) //Strongest individual are selected and avoid the crossover + .offspringSelector(new TournamentSelector<>()) //Crossover + .offspringFraction(0.7) + .populationSize(50) + //when the candidates are selected it is necessary specify how they crossover and how they mutate + .build(); + + // 4.) Start the execution (evolution) and + // collect the result. + Genotype result = engine.stream() + .limit(100) + .collect(EvolutionResult.toBestGenotype()); + + System.out.println("Hello World:\n" + result); + } + +} + + + +/* + * CROSSOVER + * The crossover operator is the process in which individuals from the + * population trade genetic information, hopefully to create a new individual + * which contains the best parts from its parents’ genomes. During crossover + * each individual in the population is considered for crossover; this is where + * the crossover rate parameter is used. By comparing the crossover rate to a + * random number, we can decide whether the individual should have crossover + * applied to it, or whether it should be added straight into the next + * population unaffected by crossover. If an individual is selected for + * crossover then a second parent needs be found. To find the second parent, we + * need to pick one of many possible selection methods. + */ \ No newline at end of file diff --git a/src/main/java/or/solver/GridSearch.java b/src/main/java/or/solver/GridSearch.java deleted file mode 100644 index c695004..0000000 --- a/src/main/java/or/solver/GridSearch.java +++ /dev/null @@ -1,14 +0,0 @@ -/** - * - */ -package or.solver; - -/** - * @author stefanopenazzi - * - */ -public class GridSearch implements SolverI{ - - - -} diff --git a/src/main/java/or/solver/Jenetics.java b/src/main/java/or/solver/Jenetics.java new file mode 100644 index 0000000..62982f9 --- /dev/null +++ b/src/main/java/or/solver/Jenetics.java @@ -0,0 +1,75 @@ +/** + * + */ +package or.solver; + +import or.model.SMASJeneticModel; +import or.model.StrategyJeneticModelAbstract; +import java.util.function.Function; + +import io.jenetics.Chromosome; +import io.jenetics.Genotype; +import io.jenetics.IntegerChromosome; +import io.jenetics.IntegerGene; +import io.jenetics.Phenotype; +import io.jenetics.RouletteWheelSelector; +import io.jenetics.TournamentSelector; +import io.jenetics.engine.Codec; +import io.jenetics.engine.Engine; +import io.jenetics.engine.EvolutionResult; +import io.jenetics.engine.EvolutionStatistics; +import io.jenetics.engine.Problem; +import io.jenetics.stat.DoubleMomentStatistics; +import io.jenetics.util.ISeq; +import io.jenetics.util.IntRange; + +/** + * @author stefanopenazzi + * + */ +public final class Jenetics implements SolverI { + + private final T modelC; + + public Jenetics(T modelC) { + this.modelC = modelC; + + } + + @Override + public T getModel() { + return this.modelC; + } + + @SuppressWarnings("unchecked") + private static final Genotype ENCODING = Genotype.of(IntegerChromosome.of(0, 100, 2)); + + @Override + public void run() { + + @SuppressWarnings({ "unchecked", "rawtypes" }) + Engine engine = Engine + .builder(this.modelC.getFitnessFunction(),ENCODING) + .constraint(this.modelC.getConstraint()) + .populationSize(30) + .offspringFraction(0.7) + .survivorsSelector(new RouletteWheelSelector<>()) + .offspringSelector(new TournamentSelector<>()) + .build(); + + final EvolutionStatistics statistics = + EvolutionStatistics.ofNumber(); + + // Start the execution (evolution) and + // collect the result. + @SuppressWarnings({ "unchecked", "rawtypes" }) + final Phenotype best = (Phenotype)engine.stream() + .limit(60) + .peek(statistics) + .collect(EvolutionResult.toBestPhenotype()); + System.out.println("Best phenotype: "); + System.out.println( best); + System.out.println(statistics); + } + +} diff --git a/src/main/java/or/solver/SolverI.java b/src/main/java/or/solver/SolverI.java index 648bf46..af745c0 100644 --- a/src/main/java/or/solver/SolverI.java +++ b/src/main/java/or/solver/SolverI.java @@ -3,10 +3,15 @@ */ package or.solver; +import or.model.ModelI; + /** * @author stefanopenazzi * */ -public interface SolverI { +public interface SolverI { + + public T getModel(); + public void run(); } diff --git a/src/main/java/strategies/DualExpMovingAverageCrossoverStrategy.java b/src/main/java/strategies/DualExpMovingAverageCrossoverStrategy.java index b292748..fb11efc 100644 --- a/src/main/java/strategies/DualExpMovingAverageCrossoverStrategy.java +++ b/src/main/java/strategies/DualExpMovingAverageCrossoverStrategy.java @@ -5,6 +5,8 @@ import data.source.internal.timeseries.TimeSeriesI; import indicators.movingAverage.ExponentialMovingAverage; +import strategies.positionsizing.FixedMoneyAmount; +import strategies.positionsizing.PositionSizingI; /** * @author stefanopenazzi @@ -12,7 +14,8 @@ */ public class DualExpMovingAverageCrossoverStrategy extends DualMovingAverageCrossoverStrategy { - public final static class Builder extends DualMovingAverageCrossoverStrategy.Builder { + + public final static class Builder extends DualMovingAverageCrossoverStrategy.Builder { private TimeSeriesI ts; private int lengthStma = 7; @@ -20,6 +23,9 @@ public final static class Builder extends DualMovingAverageCrossoverStrategy.Bui private String source = "close"; private double smoothingStma = 2; private double smoothingLtma = 2; + private PositionSizingI ps = new FixedMoneyAmount.Builder() + .fixedMoneyAmount(10000) + .build(); public Builder(TimeSeriesI ts) { this.ts = ts; @@ -36,32 +42,61 @@ public Builder source(String source){ this.source = source; return this; } - public Builder offsetShortTermMA(double smoothingStma){ + public Builder smoothingShortTermMA(double smoothingStma){ this.smoothingStma = smoothingStma; return this; } - public Builder offsetLongTermMA(double smoothingLtma){ + public Builder smoothingLongTermMA(double smoothingLtma){ this.smoothingLtma = smoothingLtma; return this; + } + public Builder positionSizing(PositionSizingI ps){ + this.ps = ps; + return this; } public DualExpMovingAverageCrossoverStrategy build() throws Exception{ - DualExpMovingAverageCrossoverStrategy demac = new DualExpMovingAverageCrossoverStrategy (); - demac.itsRef = this.ts; - demac.source = this.source; - demac.stma = new ExponentialMovingAverage.Builder(this.ts) - .length(this.lengthStma) - .source(this.source) - .smoothing(this.smoothingStma) + DualExpMovingAverageCrossoverStrategy demac = new DualExpMovingAverageCrossoverStrategy (this.ts, + this.lengthStma, + this.lengthLtma, + this.source, + this.smoothingStma, + this.smoothingLtma, + this.ps); + return demac; + } + } + + public DualExpMovingAverageCrossoverStrategy(TimeSeriesI ts, + int lengthShortTermMA, + int lengthLongTermMA, + String source, + double smoothingShortTermMA, + double smoothingLongTermMA, + PositionSizingI positionSizing) { + super(positionSizing); + + this.itsRef = ts; + this.source = source; + try { + this.stma = new ExponentialMovingAverage.Builder(ts) + .length(lengthShortTermMA) + .source(source) + .smoothing(smoothingShortTermMA) .build() .run(); - demac.ltma = new ExponentialMovingAverage.Builder(this.ts) - .length(this.lengthLtma) - .source(this.source) - .smoothing(this.smoothingLtma) + } catch (Exception e) { + e.printStackTrace(); + } + try { + this.ltma = new ExponentialMovingAverage.Builder(ts) + .length(lengthLongTermMA) + .source(source) + .smoothing(smoothingLongTermMA) .build() .run(); - - return demac; - } + } catch (Exception e) { + e.printStackTrace(); + } + } } diff --git a/src/main/java/strategies/DualMovingAverageCrossoverStrategy.java b/src/main/java/strategies/DualMovingAverageCrossoverStrategy.java index 5be3313..4ee0c8a 100644 --- a/src/main/java/strategies/DualMovingAverageCrossoverStrategy.java +++ b/src/main/java/strategies/DualMovingAverageCrossoverStrategy.java @@ -5,11 +5,10 @@ import java.time.Instant; import java.util.List; - import data.source.internal.timeseries.TimeSeriesI; import data.source.internal.timeseries.point.TimeSeriesPointI; import strategies.Position.PositionType; -import strategies.StrategiesAnnotations.StrategyVariable; +import strategies.positionsizing.PositionSizingI; /** * @author stefanopenazzi @@ -17,12 +16,17 @@ */ public class DualMovingAverageCrossoverStrategy extends StrategyAbstract { + /** + * @param positionSizing + */ + public DualMovingAverageCrossoverStrategy(PositionSizingI positionSizing) { + super(positionSizing); + } + private static final String strategyName = "DualMovingAverageCrossoverStrategy"; protected TimeSeriesI itsRef; - @StrategyVariable protected TimeSeriesI stma; - @StrategyVariable protected TimeSeriesI ltma; protected String source; @@ -59,10 +63,11 @@ public void run() { if(positions.size()>=1) { positions.get(positions.size()-1).addNewSignal((double)itsRefCopy.get(i).getTagValue(this.source), volume, itsRefCopy.get(i).getTime()); } + double price = (double)itsRefCopy.get(i).getTagValue(this.source); Position position = new Position.Builder(PositionType.SHORT) .securityId(secId ) - .price((double)itsRefCopy.get(i).getTagValue(this.source)) - .initialVolume(volume) + .price(price) + .initialVolume(this.positionSizing.getSize(this, price)) .openInstant(itsRefCopy.get(i).getTime()) .build(); positions.add(position); @@ -74,10 +79,11 @@ public void run() { if(positions.size()>=1) { positions.get(positions.size()-1).addNewSignal((double)itsRefCopy.get(i).getTagValue(this.source), volume, itsRefCopy.get(i).getTime()); } + double price = (double)itsRefCopy.get(i).getTagValue(this.source); Position position = new Position.Builder(PositionType.LONG) .securityId(secId ) - .price((double)itsRefCopy.get(i).getTagValue(this.source)) - .initialVolume(volume) + .price(price) + .initialVolume(this.positionSizing.getSize(this, price)) .openInstant(itsRefCopy.get(i).getTime()) .build(); positions.add(position); @@ -87,4 +93,5 @@ public void run() { } + } \ No newline at end of file diff --git a/src/main/java/strategies/DualSimpleMovingAverageCrossoverStrategy.java b/src/main/java/strategies/DualSimpleMovingAverageCrossoverStrategy.java index 6dd7f04..4d17649 100644 --- a/src/main/java/strategies/DualSimpleMovingAverageCrossoverStrategy.java +++ b/src/main/java/strategies/DualSimpleMovingAverageCrossoverStrategy.java @@ -5,14 +5,19 @@ import data.source.internal.timeseries.TimeSeriesI; import indicators.movingAverage.SimpleMovingAverage; +import strategies.SingleExpMovingAverageStrategy.Builder; +import strategies.positionsizing.FixedMoneyAmount; +import strategies.positionsizing.PositionSizingI; + /** * @author stefanopenazzi * */ public final class DualSimpleMovingAverageCrossoverStrategy extends DualMovingAverageCrossoverStrategy { - - public final static class Builder extends DualMovingAverageCrossoverStrategy.Builder { + + + public final static class Builder extends DualMovingAverageCrossoverStrategy.Builder { private TimeSeriesI ts; private int lengthStma = 7; @@ -20,6 +25,9 @@ public final static class Builder extends DualMovingAverageCrossoverStrategy.Bui private String source = "close"; private int offsetStma = 0; private int offsetLtma = 0; + private PositionSizingI ps = new FixedMoneyAmount.Builder() + .fixedMoneyAmount(10000) + .build(); public Builder(TimeSeriesI ts) { this.ts = ts; @@ -28,6 +36,7 @@ public Builder lengthShortTermMA(int length){ this.lengthStma = length; return this; } + public Builder lengthLongTermMA(int length){ this.lengthLtma = length; return this; @@ -43,9 +52,19 @@ public Builder offsetShortTermMA(int offset){ public Builder offsetLongTermMA(int offset){ this.offsetLtma = offset; return this; + } + public Builder positionSizing(PositionSizingI ps){ + this.ps = ps; + return this; } public DualSimpleMovingAverageCrossoverStrategy build() throws Exception{ - DualSimpleMovingAverageCrossoverStrategy smas = new DualSimpleMovingAverageCrossoverStrategy (); + DualSimpleMovingAverageCrossoverStrategy smas = new DualSimpleMovingAverageCrossoverStrategy (this.ts, + this.lengthStma, + this.lengthLtma, + this.source, + this.offsetStma, + this.offsetLtma, + this.ps); smas.itsRef = this.ts; smas.source = this.source; smas.stma = new SimpleMovingAverage.Builder(this.ts) @@ -64,5 +83,38 @@ public DualSimpleMovingAverageCrossoverStrategy build() throws Exception{ return smas; } } + + public DualSimpleMovingAverageCrossoverStrategy(TimeSeriesI ts, + int lengthShortTermMA, + int lengthLongTermMA, + String source, + int offsetShortTermMA, + int offsetLongTermMA, + PositionSizingI positionSizing) { + super(positionSizing); + this.itsRef = ts; + this.source = source; + try { + this.stma = new SimpleMovingAverage.Builder(ts) + .length(lengthShortTermMA) + .source(source) + .offset(offsetShortTermMA) + .build() + .run(); + } catch (Exception e) { + e.printStackTrace(); + } + try { + this.ltma = new SimpleMovingAverage.Builder(ts) + .length(lengthLongTermMA) + .source(source) + .offset(offsetLongTermMA) + .build() + .run(); + } catch (Exception e) { + e.printStackTrace(); + } + + } } diff --git a/src/main/java/strategies/SingleExpMovingAverageStrategy.java b/src/main/java/strategies/SingleExpMovingAverageStrategy.java index c902f4b..306d8e6 100644 --- a/src/main/java/strategies/SingleExpMovingAverageStrategy.java +++ b/src/main/java/strategies/SingleExpMovingAverageStrategy.java @@ -7,6 +7,8 @@ import indicators.movingAverage.ExponentialMovingAverage; import indicators.movingAverage.SimpleMovingAverage; import strategies.SingleSimpleMovingAverageStrategy.Builder; +import strategies.positionsizing.FixedMoneyAmount; +import strategies.positionsizing.PositionSizingI; /** * @author stefanopenazzi @@ -19,6 +21,9 @@ public static final class Builder extends SingleMovingAverageCrossoverStrategy.B private int length = 9; private String source = "close"; private double smoothing = 2; + private PositionSizingI ps = new FixedMoneyAmount.Builder() + .fixedMoneyAmount(10000) + .build(); public Builder(TimeSeriesI ts) { this.ts = ts; @@ -34,25 +39,32 @@ public Builder source(String source){ public Builder smoothing(double smoothing){ this.smoothing = smoothing; return this; + } + public Builder positionSizing(PositionSizingI ps){ + this.ps = ps; + return this; } public SingleExpMovingAverageStrategy build(){ - SingleExpMovingAverageStrategy smas = new SingleExpMovingAverageStrategy (); - smas.itsRef = this.ts; - smas.source = this.source; - try { - smas.ma = new ExponentialMovingAverage.Builder(this.ts) - .length(this.length) - .source(this.source) - .smoothing(this.smoothing) - .build() - .run(); - } catch (Exception e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - + SingleExpMovingAverageStrategy smas = new SingleExpMovingAverageStrategy (this.ts,this.source,this.length,this.smoothing,this.ps); return smas; } } + + public SingleExpMovingAverageStrategy(TimeSeriesI ts,String source,int length,double smoothing, PositionSizingI ps) { + super(ps); + this.itsRef = ts; + this.source = source; + try { + this.ma = new ExponentialMovingAverage.Builder(ts) + .length(length) + .source(source) + .smoothing(smoothing) + .build() + .run(); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } } diff --git a/src/main/java/strategies/SingleMovingAverageCrossoverStrategy.java b/src/main/java/strategies/SingleMovingAverageCrossoverStrategy.java index 0195bbd..eb0e7a1 100644 --- a/src/main/java/strategies/SingleMovingAverageCrossoverStrategy.java +++ b/src/main/java/strategies/SingleMovingAverageCrossoverStrategy.java @@ -3,17 +3,13 @@ */ package strategies; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; import java.time.Instant; import java.util.List; - import data.source.internal.timeseries.TimeSeriesI; import data.source.internal.timeseries.point.TimeSeriesPointI; -import indicators.movingAverage.SimpleMovingAverage; import strategies.Position.PositionType; -import strategies.SingleSimpleMovingAverageStrategy.Builder; -import strategies.StrategiesAnnotations.StrategyVariable; +import strategies.positionsizing.PositionSizingI; + /** * @author stefanopenazzi @@ -21,10 +17,16 @@ */ public class SingleMovingAverageCrossoverStrategy extends StrategyAbstract { + /** + * @param positionSizing + */ + public SingleMovingAverageCrossoverStrategy(PositionSizingI positionSizing) { + super(positionSizing); + } + private static final String strategyName = "SingleMovingAverageCrossoverStrategy"; protected TimeSeriesI itsRef; - @StrategyVariable protected TimeSeriesI ma; protected String source; @@ -45,7 +47,7 @@ public void run() { List itsRefCopy = this.itsRef.getListFromTo(from,to); List smaCopy = this.ma.getListFromTo(from,to); - boolean up = (double)itsRefCopy.get(0).getTagValue(this.source) >= (double)smaCopy.get(0).getTagValue("value") ? true: false; + boolean up = (double)itsRefCopy.get(0).getTagValue(this.source) <= (double)smaCopy.get(0).getTagValue("value") ? true: false; int volume = 100; @@ -59,7 +61,7 @@ public void run() { smaVal = (double) smaCopy.get(i).getTagValue("value"); if(up) { - if(refVal < smaVal) { + if(smaVal=1) { positions.get(positions.size()-1).addNewSignal(refVal, volume, itsRefCopy.get(i).getTime()); @@ -67,14 +69,14 @@ public void run() { Position position = new Position.Builder(PositionType.SHORT) .securityId(secId) .price(refVal) - .initialVolume(volume) + .initialVolume(this.positionSizing.getSize(this, refVal)) .openInstant(itsRefCopy.get(i).getTime()) .build(); positions.add(position); } } else { - if(refVal > smaVal) { + if(smaVal > refVal) { up = true; if(positions.size()>=1) { positions.get(positions.size()-1).addNewSignal(refVal, volume, itsRefCopy.get(i).getTime()); @@ -82,7 +84,7 @@ public void run() { Position position = new Position.Builder(PositionType.LONG) .securityId(secId) .price(refVal) - .initialVolume(volume) + .initialVolume(this.positionSizing.getSize(this, refVal)) .openInstant(itsRefCopy.get(i).getTime()) .build(); positions.add(position); diff --git a/src/main/java/strategies/SingleSimpleMovingAverageStrategy.java b/src/main/java/strategies/SingleSimpleMovingAverageStrategy.java index 9a50776..3b47ad8 100644 --- a/src/main/java/strategies/SingleSimpleMovingAverageStrategy.java +++ b/src/main/java/strategies/SingleSimpleMovingAverageStrategy.java @@ -5,6 +5,9 @@ import data.source.internal.timeseries.TimeSeriesI; import indicators.movingAverage.SimpleMovingAverage; +import strategies.StrategiesAnnotations.StrategyVariable; +import strategies.positionsizing.FixedMoneyAmount; +import strategies.positionsizing.PositionSizingI; /** @@ -14,14 +17,18 @@ public final class SingleSimpleMovingAverageStrategy extends SingleMovingAverageCrossoverStrategy { public static final class Builder extends SingleMovingAverageCrossoverStrategy.Builder { - private TimeSeriesI ts; + private TimeSeriesI ts; private int length = 50; private String source = "close"; private int offset = 0; + private PositionSizingI ps = new FixedMoneyAmount.Builder() + .fixedMoneyAmount(10000) + .build(); public Builder(TimeSeriesI ts) { this.ts = ts; } + @StrategyVariable(name = "length") public Builder length(int length){ this.length = length; return this; @@ -33,26 +40,32 @@ public Builder source(String source){ public Builder offset(int offset){ this.offset = offset; return this; + } + public Builder positionSizing(PositionSizingI ps){ + this.ps = ps; + return this; } public SingleSimpleMovingAverageStrategy build(){ - SingleSimpleMovingAverageStrategy smas = new SingleSimpleMovingAverageStrategy (); - smas.itsRef = this.ts; - smas.source = this.source; - - try { - smas.ma = new SimpleMovingAverage.Builder(this.ts) - .length(this.length) - .source(this.source) - .offset(this.offset) - .build() - .run(); - } catch (Exception e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - + SingleSimpleMovingAverageStrategy smas = new SingleSimpleMovingAverageStrategy (this.ts,this.source,this.length,this.offset,this.ps); return smas; } } + + + public SingleSimpleMovingAverageStrategy(TimeSeriesI ts,String source,int length,int offset, PositionSizingI ps) { + super(ps); + this.itsRef = ts; + this.source = source; + try { + this.ma = new SimpleMovingAverage.Builder(ts) + .length(length) + .source(source) + .offset(offset) + .build() + .run(); + } catch (Exception e) { + e.printStackTrace(); + } + } } diff --git a/src/main/java/strategies/StrategiesAnnotations.java b/src/main/java/strategies/StrategiesAnnotations.java index 7a0a664..7efdb65 100644 --- a/src/main/java/strategies/StrategiesAnnotations.java +++ b/src/main/java/strategies/StrategiesAnnotations.java @@ -31,7 +31,7 @@ public interface StrategiesAnnotations { } @Retention(RetentionPolicy.RUNTIME) - @Target(ElementType.FIELD) + @Target(ElementType.METHOD) public @interface StrategyVariable { String name() default ""; } diff --git a/src/main/java/strategies/StrategyAbstract.java b/src/main/java/strategies/StrategyAbstract.java index b006fd9..3de713e 100644 --- a/src/main/java/strategies/StrategyAbstract.java +++ b/src/main/java/strategies/StrategyAbstract.java @@ -11,6 +11,7 @@ import java.util.stream.Collectors; import strategies.StrategiesAnnotations.InputStrategyReport; import strategies.StrategiesAnnotations.OutputStrategyReport; +import strategies.positionsizing.PositionSizingI; /** @@ -21,6 +22,8 @@ public abstract class StrategyAbstract implements StrategyI { protected List positions = new ArrayList<>(); + protected PositionSizingI positionSizing; + protected static abstract class Builder > {} private enum ReportElementType{ @@ -51,11 +54,20 @@ public ReportElement(ReportElementType ret, String name,String section,int posit } + public StrategyAbstract(PositionSizingI positionSizing) { + this.positionSizing = positionSizing; + } + @Override public List getPositions() { return this.positions; } + @Override + public PositionSizingI getPositionSizing() { + return this.positionSizing; + } + @Override @OutputStrategyReport(name = "Position details",section="Details",position=0) public String printPositions() { @@ -107,7 +119,7 @@ public Double getTotNetProfit() { @OutputStrategyReport(name = "Profit Factor",section="Main",position=3) public Double getProfitFactor() { - return getGrossProfit()/getGrossLoss(); + return Math.abs(getGrossProfit()/getGrossLoss()); } @Override @@ -239,6 +251,15 @@ public Double getMaxTradeDrawdown() { return 0.0; } + @OutputStrategyReport(name = "ROI",section="Main",position=19) + public Double getROI() { + Double res = 0.0; + for(Position position: positions) { + res += position.getInitPrice() * position.getInitVolume(); + } + return getTotNetProfit()/res; + } + @Override public String getPerformanceReport() { String res = ""; diff --git a/src/main/java/strategies/StrategyI.java b/src/main/java/strategies/StrategyI.java index 4781405..9d49fff 100644 --- a/src/main/java/strategies/StrategyI.java +++ b/src/main/java/strategies/StrategyI.java @@ -5,6 +5,8 @@ import java.util.List; +import strategies.positionsizing.PositionSizingI; + /** * @author stefanopenazzi * @@ -12,6 +14,7 @@ public interface StrategyI { public void run(); + public PositionSizingI getPositionSizing(); public String getStrategyName(); public Integer getTotNumOfTrades(); public Double getGrossProfit(); diff --git a/src/main/java/strategies/TripleExpMovingAverageCrossoverStrategy.java b/src/main/java/strategies/TripleExpMovingAverageCrossoverStrategy.java index 79ead9f..59bd0e7 100644 --- a/src/main/java/strategies/TripleExpMovingAverageCrossoverStrategy.java +++ b/src/main/java/strategies/TripleExpMovingAverageCrossoverStrategy.java @@ -5,6 +5,10 @@ import data.source.internal.timeseries.TimeSeriesI; import indicators.movingAverage.ExponentialMovingAverage; +import indicators.movingAverage.SimpleMovingAverage; +import strategies.DualExpMovingAverageCrossoverStrategy.Builder; +import strategies.positionsizing.FixedMoneyAmount; +import strategies.positionsizing.PositionSizingI; /** @@ -12,8 +16,8 @@ * */ public class TripleExpMovingAverageCrossoverStrategy extends TripleMovingAverageCrossoverStrategy { - - public static class Builder extends TripleMovingAverageCrossoverStrategy.Builder { + + public static class Builder extends TripleMovingAverageCrossoverStrategy.Builder { private TimeSeriesI ts; private int lengthStma = 7; @@ -25,6 +29,9 @@ public static class Builder extends TripleMovingAverageCrossoverStrategy.Builder private double smoothingLtma = 2; private double targetRange = 1; + private PositionSizingI ps = new FixedMoneyAmount.Builder() + .fixedMoneyAmount(10000) + .build(); public Builder(TimeSeriesI ts) { this.ts = ts; @@ -62,34 +69,62 @@ public Builder targetRange(double targetRange){ this.targetRange = targetRange; return this; } + public Builder positionSizing(PositionSizingI ps){ + this.ps = ps; + return this; + } + public TripleExpMovingAverageCrossoverStrategy build() throws Exception{ - TripleExpMovingAverageCrossoverStrategy smas = new TripleExpMovingAverageCrossoverStrategy(); - smas.itsRef = this.ts; - smas.source = this.source; - smas.targetRange = this.targetRange; - smas.stma = new ExponentialMovingAverage.Builder(this.ts) - .length(this.lengthStma) - .source(this.source) - .smoothing(this.smoothingStma) - .build() - .run(); - smas.mtma = new ExponentialMovingAverage.Builder(this.ts) - .length(this.lengthMtma) - .source(this.source) - .smoothing(this.smoothingMtma) - .build() - .run(); - smas.ltma = new ExponentialMovingAverage.Builder(this.ts) - .length(this.lengthLtma) - .source(this.source) - .smoothing(this.smoothingLtma) - .build() - .run(); - + TripleExpMovingAverageCrossoverStrategy smas = new TripleExpMovingAverageCrossoverStrategy(this.ts, + this.lengthStma, + this.lengthMtma, + this.lengthLtma, + this.source, + this.smoothingStma, + this.smoothingMtma, + this.smoothingLtma, + this.targetRange, + this.ps); return smas; } } + public TripleExpMovingAverageCrossoverStrategy(TimeSeriesI ts, + int lengthShortTermMA, + int lengthMediumTermMA, + int lengthLongTermMA, + String source, + double smoothingShortTermMA, + double smoothingMediumTermMA, + double smoothingLongTermMA, + double targetRange, + PositionSizingI positionSizing) throws Exception { + super(positionSizing); + + this.itsRef = ts; + this.source = source; + this.targetRange = targetRange; + this.stma = new ExponentialMovingAverage.Builder(ts) + .length(lengthShortTermMA) + .source(source) + .smoothing(smoothingShortTermMA) + .build() + .run(); + this.mtma = new ExponentialMovingAverage.Builder(ts) + .length(lengthMediumTermMA) + .source(source) + .smoothing(smoothingMediumTermMA) + .build() + .run(); + this.ltma = new ExponentialMovingAverage.Builder(ts) + .length(lengthLongTermMA) + .source(source) + .smoothing(smoothingLongTermMA) + .build() + .run(); + + } + } diff --git a/src/main/java/strategies/TripleMovingAverageCrossoverStrategy.java b/src/main/java/strategies/TripleMovingAverageCrossoverStrategy.java index f0b80c9..9ce5b13 100644 --- a/src/main/java/strategies/TripleMovingAverageCrossoverStrategy.java +++ b/src/main/java/strategies/TripleMovingAverageCrossoverStrategy.java @@ -6,11 +6,11 @@ import java.time.Instant; import java.util.ArrayList; import java.util.List; - import data.source.internal.timeseries.TimeSeriesI; import data.source.internal.timeseries.point.TimeSeriesPointI; import strategies.Position.PositionType; -import strategies.StrategiesAnnotations.StrategyVariable; +import strategies.positionsizing.PositionSizingI; + /** * @author stefanopenazzi @@ -18,14 +18,18 @@ */ public class TripleMovingAverageCrossoverStrategy extends StrategyAbstract { + /** + * @param positionSizing + */ + public TripleMovingAverageCrossoverStrategy(PositionSizingI positionSizing) { + super(positionSizing); + } + private static final String strategyName = "TripleMovingAverageCrossoverStrategy"; protected TimeSeriesI itsRef; - @StrategyVariable protected TimeSeriesI stma; - @StrategyVariable protected TimeSeriesI mtma; - @StrategyVariable protected TimeSeriesI ltma; protected String source; protected double targetRange; @@ -137,11 +141,11 @@ public void run() { crossPairSecond.key == CrossKey.SHORTXLONG && crossPairSecond.value == CrossValue.UP && crossPairThird.key == CrossKey.MEDIUMXLONG && crossPairThird.value == CrossValue.UP) { inLong = true; - + double price = (double)itsRefCopy.get(i).getTagValue(this.source); Position position = new Position.Builder(PositionType.LONG) .securityId(secId) .price((double)itsRefCopy.get(i).getTagValue(this.source)) - .initialVolume(volume) + .initialVolume(this.positionSizing.getSize(this, price)) .openInstant(itsRefCopy.get(i).getTime()) .build(); positions.add(position); @@ -154,11 +158,11 @@ public void run() { crossPairSecond.key == CrossKey.SHORTXLONG && crossPairSecond.value == CrossValue.DOWN && crossPairThird.key == CrossKey.MEDIUMXLONG && crossPairThird.value == CrossValue.DOWN) { inShort = true; - + double price = (double)itsRefCopy.get(i).getTagValue(this.source); Position position = new Position.Builder(PositionType.SHORT) .securityId(secId) .price((double)itsRefCopy.get(i).getTagValue(this.source)) - .initialVolume(volume) + .initialVolume(this.positionSizing.getSize(this, price)) .openInstant(itsRefCopy.get(i).getTime()) .build(); positions.add(position); diff --git a/src/main/java/strategies/TripleSimpleMovingAverageCrossoverStrategy.java b/src/main/java/strategies/TripleSimpleMovingAverageCrossoverStrategy.java index bad1471..d232349 100644 --- a/src/main/java/strategies/TripleSimpleMovingAverageCrossoverStrategy.java +++ b/src/main/java/strategies/TripleSimpleMovingAverageCrossoverStrategy.java @@ -5,6 +5,9 @@ import data.source.internal.timeseries.TimeSeriesI; import indicators.movingAverage.SimpleMovingAverage; +import strategies.DualExpMovingAverageCrossoverStrategy.Builder; +import strategies.positionsizing.FixedMoneyAmount; +import strategies.positionsizing.PositionSizingI; /** * @author stefanopenazzi @@ -12,7 +15,9 @@ */ public class TripleSimpleMovingAverageCrossoverStrategy extends TripleMovingAverageCrossoverStrategy { - public static class Builder extends TripleMovingAverageCrossoverStrategy.Builder { + + + public static class Builder extends TripleMovingAverageCrossoverStrategy.Builder { private TimeSeriesI ts; private int lengthStma = 7; @@ -22,6 +27,9 @@ public static class Builder extends TripleMovingAverageCrossoverStrategy.Builder private int offsetStma = 0; private int offsetMtma = 0; private int offsetLtma = 0; + private PositionSizingI ps = new FixedMoneyAmount.Builder() + .fixedMoneyAmount(10000) + .build(); private double targetRange = 1; @@ -61,35 +69,61 @@ public Builder targetRange(double targetRange){ this.targetRange = targetRange; return this; } + public Builder positionSizing(PositionSizingI ps){ + this.ps = ps; + return this; + } public TripleSimpleMovingAverageCrossoverStrategy build() throws Exception{ - TripleSimpleMovingAverageCrossoverStrategy smas = new TripleSimpleMovingAverageCrossoverStrategy (); - - smas.itsRef = this.ts; - smas.source = this.source; - smas.targetRange = this.targetRange; - smas.stma = new SimpleMovingAverage.Builder(this.ts) - .length(this.lengthStma) - .source(this.source) - .offset(this.offsetStma) - .build() - .run(); - smas.mtma = new SimpleMovingAverage.Builder(this.ts) - .length(this.lengthMtma) - .source(this.source) - .offset(this.offsetMtma) - .build() - .run(); - smas.ltma = new SimpleMovingAverage.Builder(this.ts) - .length(this.lengthLtma) - .source(this.source) - .offset(this.offsetLtma) - .build() - .run(); - + TripleSimpleMovingAverageCrossoverStrategy smas = new TripleSimpleMovingAverageCrossoverStrategy (this.ts, + this.lengthStma, + this.lengthMtma, + this.lengthLtma, + this.source, + this.offsetStma, + this.offsetMtma, + this.offsetLtma, + this.targetRange, + this.ps); return smas; } } + + public TripleSimpleMovingAverageCrossoverStrategy(TimeSeriesI ts, + int lengthShortTermMA, + int lengthMediumTermMA, + int lengthLongTermMA, + String source, + int offsetShortTermMA, + int offsetMediumTermMA, + int offsetLongTermMA, + double targetRange, + PositionSizingI positionSizing) throws Exception { + super(positionSizing); + this.itsRef = ts; + this.source = source; + this.targetRange = targetRange; + this.stma = new SimpleMovingAverage.Builder(ts) + .length(lengthShortTermMA) + .source(source) + .offset(offsetShortTermMA) + .build() + .run(); + this.mtma = new SimpleMovingAverage.Builder(ts) + .length(lengthMediumTermMA) + .source(source) + .offset(offsetMediumTermMA) + .build() + .run(); + this.ltma = new SimpleMovingAverage.Builder(ts) + .length(lengthLongTermMA) + .source(source) + .offset(offsetLongTermMA) + .build() + .run(); + + } + } diff --git a/src/main/java/strategies/positionsizing/FixedMoneyAmount.java b/src/main/java/strategies/positionsizing/FixedMoneyAmount.java new file mode 100644 index 0000000..7678a7b --- /dev/null +++ b/src/main/java/strategies/positionsizing/FixedMoneyAmount.java @@ -0,0 +1,42 @@ +/** + * + */ +package strategies.positionsizing; + +import strategies.StrategyI; + +/** + * @author stefanopenazzi + * + */ +public final class FixedMoneyAmount implements PositionSizingI { + + private double fm; + + public final static class Builder{ + + private double fm = 0; + + public Builder fixedMoneyAmount(double fm){ + this.fm = fm; + return this; + } + public FixedMoneyAmount build(){ + FixedMoneyAmount ps = new FixedMoneyAmount(this.fm); + return ps; + } + + } + + @Deprecated + public FixedMoneyAmount(double fm) { + this.fm = fm; + } + + @Override + public int getSize(StrategyI strategy, double price) { + return (int)Math.floor(this.fm/price); + } + +} + diff --git a/src/main/java/strategies/positionsizing/PositionSizingI.java b/src/main/java/strategies/positionsizing/PositionSizingI.java new file mode 100644 index 0000000..e337ffa --- /dev/null +++ b/src/main/java/strategies/positionsizing/PositionSizingI.java @@ -0,0 +1,16 @@ +/** + * + */ +package strategies.positionsizing; + +import strategies.StrategyI; + +/** + * @author stefanopenazzi + * + */ +public interface PositionSizingI { + + public int getSize(StrategyI strategy, double price); + +} diff --git a/src/test/java/data/source/external/database/TestInfluxdb.java b/src/test/java/data/source/external/database/TestInfluxdb.java index beed84d..b2280f5 100644 --- a/src/test/java/data/source/external/database/TestInfluxdb.java +++ b/src/test/java/data/source/external/database/TestInfluxdb.java @@ -39,8 +39,8 @@ void testUpdateAlphaVantageEOD() { //stocksList.add("ACIA"); //stocksList.add("AAL"); - stocksList.add("AMZN"); - //stocksList.add("BAND"); + stocksList.add("KO"); + stocksList.add("KODK"); //stocksList.add("BANF"); //stocksList.add("BANFP"); //stocksList.add("BAN"); diff --git a/src/test/java/or/solver/TestSolver.java b/src/test/java/or/solver/TestSolver.java new file mode 100644 index 0000000..f4a09d5 --- /dev/null +++ b/src/test/java/or/solver/TestSolver.java @@ -0,0 +1,56 @@ +/** + * + */ +package or.solver; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.Instant; +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.Test; +import controller.Controller; +import data.source.external.database.influxdb.TimeSeriesRequestIdInfluxdb; +import data.source.internal.dataset.DatasetI; +import data.source.internal.timeseries.TimeSeriesRequestIdI; +import data.source.internal.timeseries.standard.TimeSeriesIdImpl; +import or.model.SSMASJeneticModel; +import strategies.SingleSimpleMovingAverageStrategy; + +/** + * @author stefanopenazzi + * + */ +class TestSolver { + + @Test + void testJenetics() throws ParseException { + + Controller.run(); + + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + Instant startInstant = (sdf.parse("2018-01-01 00:00:00")).toInstant(); + Instant endInstant = null; + + List listQueries = new ArrayList<>(); + listQueries.add(new TimeSeriesRequestIdInfluxdb.Builder(new TimeSeriesIdImpl.Builder("KO") + .startInstant(startInstant) + .endInstant(endInstant) + .interval("1d") + .build()) + .build()); + + + DatasetI dts = Controller.getDatasetFactory().create(listQueries); + + SSMASJeneticModel jModel = new SSMASJeneticModel(SingleSimpleMovingAverageStrategy.class,dts.getTimeSeries(new TimeSeriesIdImpl.Builder("KO") + .startInstant(startInstant) + .endInstant(endInstant) + .interval("1d") + .build())); + + Jenetics jen = new Jenetics(jModel); + jen.run(); + } + +} diff --git a/src/test/java/strategies/TestStrategies.java b/src/test/java/strategies/TestStrategies.java index 36f5065..7f76451 100644 --- a/src/test/java/strategies/TestStrategies.java +++ b/src/test/java/strategies/TestStrategies.java @@ -26,11 +26,11 @@ void testSimpleMovingAverageStrategy() throws Exception { Controller.run(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); - Instant startInstant = (sdf.parse("2020-01-01 00:00:00")).toInstant(); + Instant startInstant = (sdf.parse("2018-01-01 00:00:00")).toInstant(); Instant endInstant = null; List listQueries = new ArrayList<>(); - listQueries.add(new TimeSeriesRequestIdInfluxdb.Builder(new TimeSeriesIdImpl.Builder("AMZN") + listQueries.add(new TimeSeriesRequestIdInfluxdb.Builder(new TimeSeriesIdImpl.Builder("KO") .startInstant(startInstant) .endInstant(endInstant) .interval("1d") @@ -40,13 +40,13 @@ void testSimpleMovingAverageStrategy() throws Exception { DatasetI dts = Controller.getDatasetFactory().create(listQueries); - SingleExpMovingAverageStrategy smas = new SingleExpMovingAverageStrategy.Builder(dts.getTimeSeries(new TimeSeriesIdImpl.Builder("AMZN") + SingleSimpleMovingAverageStrategy smas = new SingleSimpleMovingAverageStrategy.Builder(dts.getTimeSeries(new TimeSeriesIdImpl.Builder("KO") .startInstant(startInstant) .endInstant(endInstant) .interval("1d") .build())) .source("close") - .length(18) + .length(35) .build(); smas.run();