Thread: [Quantproject-developers] QuantProject/b7_Scripts/TechnicalAnalysisTesting/Oscillators/FixedLevelOs

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/quantproject/QuantProject/b7_Scripts/TechnicalAnalysisTesting/Oscillators/FixedLevelOscillators/PortfolioValueOscillator/WeightedPVO
In directory sc8-pr-cvs7.sourceforge.net:/tmp/cvs-serv6633/WeightedPVO

Added Files:
	RunWeightedPVO.cs GenomeManagerWeightedPVO.cs 
	EndOfDayTimerHandlerWeightedPVO.cs 
Log Message:
Added variations of Portfolio Value Oscillator strategy (some of these files have to be
tested yet and will be re-written as soon as possible ...):
- WeightedPVO: basic PVO (with thresholds);
- weigthedBalancedPVO: the weighted PVO with 50% of portfolio invested in short
positions and the remaining half in long ones;
- biasedPVO: it is not simply chosen the genome with the highest fitness
	 (as in the PVO base), but it is chosen the genome (from a 
	 given set of genomes with a good fitness) that
	 has the highest degree of deviation from a threshold;
- biasedPVO No Thresholds: as the biased, but the signal is just the highest gain or loss;
- biasedOTC_PVONoThresholds: as the previous one, but with these differences:
 new positions are opened at market open, choosing the genome 
that opens with the highest gain or loss with respect to the last close
All positions are closed at market close (at the moment ...tests are in progress ...)

--- NEW FILE: EndOfDayTimerHandlerWeightedPVO.cs ---
/*
QuantProject - Quantitative Finance Library

EndOfDayTimerHandlerWeightedPVO.cs
Copyright (C) 2006 
Marco Milletti

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
using System;
using System.Data;
using System.Collections;

using QuantProject.ADT;
using QuantProject.Business.Financial.Accounting;
using QuantProject.Business.Financial.Instruments;
using QuantProject.Business.Financial.Ordering;
using QuantProject.Business.Timing;
using QuantProject.Business.Strategies;
using QuantProject.Data;
using QuantProject.Data.DataProviders;
using QuantProject.Data.Selectors;
using QuantProject.Data.DataTables;
using QuantProject.ADT.Optimizing.Genetic;
using QuantProject.Scripts.TickerSelectionTesting.EfficientPortfolios;
using QuantProject.Scripts.WalkForwardTesting.LinearCombination;
using QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator;

namespace QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator.WeightedPVO
{
	/// <summary>
  /// Implements MarketOpenEventHandler and MarketCloseEventHandler
  /// These handlers contain the core strategy for the Portfolio Value
  /// Oscillator using weights for tickers
  /// </summary>
  [Serializable]
  public class EndOfDayTimerHandlerWeightedPVO : EndOfDayTimerHandlerPVO
  {

    public EndOfDayTimerHandlerWeightedPVO(string tickerGroupID, int numberOfEligibleTickers, 
                                int numberOfTickersToBeChosen, int numDaysForOptimizationPeriod,
                                Account account,                                
                                int generationNumberForGeneticOptimizer,
                                int populationSizeForGeneticOptimizer,
                                string benchmark,
                                int numDaysForOscillatingPeriod,
                                int minLevelForOversoldThreshold,
                                int maxLevelForOversoldThreshold,
                                int minLevelForOverboughtThreshold,
                                int maxLevelForOverboughtThreshold,
                                int divisorForThresholdComputation,
                                bool symmetricalThresholds,
                                bool overboughtMoreThanOversoldForFixedPortfolio,
                                int numDaysBetweenEachOptimization,
                                PortfolioType portfolioType, double maxAcceptableCloseToCloseDrawdown):
    														base(tickerGroupID, numberOfEligibleTickers, 
                                numberOfTickersToBeChosen, numDaysForOptimizationPeriod,
                                account,                                
                                generationNumberForGeneticOptimizer,
                                populationSizeForGeneticOptimizer,
                                benchmark,
                                numDaysForOscillatingPeriod,
                                minLevelForOversoldThreshold,
                                maxLevelForOversoldThreshold,
                                minLevelForOverboughtThreshold,
                                maxLevelForOverboughtThreshold,
                                divisorForThresholdComputation,
                                symmetricalThresholds,
                                overboughtMoreThanOversoldForFixedPortfolio,
                                numDaysBetweenEachOptimization,
                                portfolioType, maxAcceptableCloseToCloseDrawdown)
    {

    }

    protected override DataTable getSetOfTickersToBeOptimized(DateTime currentDate)
    {
			SelectorByGroup temporizedGroup = new SelectorByGroup(this.tickerGroupID, currentDate);
      DataTable tickersFromGroup = temporizedGroup.GetTableOfSelectedTickers();
      int numOfTickersInGroupAtCurrentDate = tickersFromGroup.Rows.Count;

      SelectorByAverageRawOpenPrice byPrice =
      		new SelectorByAverageRawOpenPrice(tickersFromGroup,false,currentDate.AddDays(-30),
      	                                  currentDate,
      	                                  numOfTickersInGroupAtCurrentDate,
      	                                  20,500, 0.0001,100);

      SelectorByLiquidity mostLiquidSelector =
      	new SelectorByLiquidity(byPrice.GetTableOfSelectedTickers(),
        false,currentDate.AddDays(-this.numDaysForOptimizationPeriod), currentDate,
        this.numberOfEligibleTickers);

//      SelectorByCloseToCloseCorrelationToBenchmark byCorrelationToBenchmark =
//      	new SelectorByCloseToCloseCorrelationToBenchmark(mostLiquidSelector.GetTableOfSelectedTickers(),
//      	                                                 "^GSPC",false,
//      	                                                 currentDate.AddDays(-this.numDaysForOptimizationPeriod), currentDate,
//      	                                                 this.numberOfEligibleTickers/2,false);
//      

      SelectorByQuotationAtEachMarketDay quotedAtEachMarketDayFromLastSelection = 
        new SelectorByQuotationAtEachMarketDay(mostLiquidSelector.GetTableOfSelectedTickers(),
        false, currentDate.AddDays(-this.numDaysForOptimizationPeriod), currentDate,
        this.numberOfEligibleTickers, this.benchmark);

      return quotedAtEachMarketDayFromLastSelection.GetTableOfSelectedTickers(); 

    }

    protected override void setTickers(DateTime currentDate,
      bool setGenomeCounter)
    {
      DataTable setOfTickersToBeOptimized = this.getSetOfTickersToBeOptimized(currentDate);
      if(setOfTickersToBeOptimized.Rows.Count > this.chosenTickers.Length*2)
        //the optimization process is meaningful only if the initial set of tickers is 
        //larger than the number of tickers to be chosen                     

      {
        this.iGenomeManager =
          new GenomeManagerWeightedPVO(setOfTickersToBeOptimized,
          currentDate.AddDays(-this.numDaysForOptimizationPeriod), 
          currentDate, this.numberOfTickersToBeChosen,
          this.numDaysForOscillatingPeriod,
          this.minLevelForOversoldThreshold,
          this.maxLevelForOversoldThreshold,
          this.minLevelForOverboughtThreshold,
          this.maxLevelForOverboughtThreshold,
          this.divisorForThresholdComputation,
          this.symmetricalThresholds,
          this.overboughtMoreThanOversoldForFixedPortfolio,
          this.portfolioType);
        GeneticOptimizer GO = new GeneticOptimizer(this.iGenomeManager,
          this.populationSizeForGeneticOptimizer, 
          this.generationNumberForGeneticOptimizer,
          this.seedForRandomGenerator);
        if(setGenomeCounter)
          this.genomeCounter = new GenomeCounter(GO);
        GO.MutationRate = 0.2;
        GO.Run(false);

        this.chosenTickers = ((GenomeMeaningPVO)GO.BestGenome.Meaning).Tickers;
        this.chosenTickersPortfolioWeights = ((GenomeMeaningPVO)GO.BestGenome.Meaning).TickersPortfolioWeights;
        this.currentOversoldThreshold = ((GenomeMeaningPVO)GO.BestGenome.Meaning).OversoldThreshold;
        this.currentOverboughtThreshold = ((GenomeMeaningPVO)GO.BestGenome.Meaning).OverboughtThreshold;
        this.addPVOGenomeToBestGenomes(GO.BestGenome,((GenomeManagerForEfficientPortfolio)this.iGenomeManager).FirstQuoteDate,
          ((GenomeManagerForEfficientPortfolio)this.iGenomeManager).LastQuoteDate, setOfTickersToBeOptimized.Rows.Count,
           this.numDaysForOscillatingPeriod, this.portfolioType, GO.GenerationCounter,
           this.currentOversoldThreshold, this.currentOverboughtThreshold);
      }
      //else it will be buyed again the previous optimized portfolio
      //that's it the actual chosenTickers member
    }
  }
}

--- NEW FILE: RunWeightedPVO.cs ---
/*
QuantProject - Quantitative Finance Library

RunWeightedPVO.cs
Copyright (C) 2006 
Marco Milletti

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Collections;
using System.Data;
using QuantProject.ADT;
using QuantProject.ADT.Optimizing.Genetic;
using QuantProject.Business.DataProviders;
using QuantProject.Business.Financial.Accounting;
using QuantProject.Business.Financial.Accounting.Reporting;
using QuantProject.Business.Financial.Instruments;
using QuantProject.Business.Financial.Ordering;
using QuantProject.Business.Scripting;
using QuantProject.Business.Strategies;
using QuantProject.Business.Testing;
using QuantProject.Business.Timing;
using QuantProject.Data.DataProviders;
using QuantProject.Data.Selectors; 
using QuantProject.Scripts.TickerSelectionTesting.EfficientPortfolios;
using QuantProject.Presentation.Reporting.WindowsForm;
using QuantProject.ADT.FileManaging;
using QuantProject.Scripts.WalkForwardTesting.LinearCombination;

namespace QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator.WeightedPVO
{
	/// <summary>
	/// Script that implements an oscillating strategy using weights for tickers,
	/// based on the classical technical indicator 
	/// RelativeStrengthIndex - RSI 
	/// </summary>
	[Serializable]
	public class RunWeightedPVO : RunEfficientPortfolio
	{
    protected int minLevelForOversoldThreshold;
    protected int maxLevelForOversoldThreshold;
    protected int minLevelForOverboughtThreshold;
    protected int maxLevelForOverboughtThreshold;
    protected int divisorForThresholdComputation;
    //to be used by the optimizer
    protected int numDaysBetweenEachOptimization;
    protected double maxAcceptableCloseToCloseDrawdown;
    protected int numDaysForOscillatingPeriod;
    protected bool symmetricalThresholds = false;
    protected bool overboughtMoreThanOversoldForFixedPortfolio = false;

    public RunWeightedPVO(string tickerGroupID, int maxNumOfEligibleTickersForOptimization, 
                                    int numberOfTickersToBeChosen, int numDaysForOptimizationPeriod, 
                                    int generationNumberForGeneticOptimizer,
                                    int populationSizeForGeneticOptimizer, string benchmark,
                                    DateTime startDate, DateTime endDate,
                                   	int numDaysForOscillatingPeriod,
                                    int minLevelForOversoldThreshold,
                                    int maxLevelForOversoldThreshold,
                                    int minLevelForOverboughtThreshold,
                                    int maxLevelForOverboughtThreshold,
                                    int divisorForThresholdComputation,
                                    bool symmetricalThresholds,
                                    bool overboughtMoreThanOversoldForFixedPortfolio,
                                   	int numDaysBetweenEachOptimization,
                                    PortfolioType inSamplePortfolioType, double maxAcceptableCloseToCloseDrawdown, 
                                    double maxRunningHours):
																base(tickerGroupID, maxNumOfEligibleTickersForOptimization, 
                                    numberOfTickersToBeChosen, numDaysForOptimizationPeriod, 
                                    generationNumberForGeneticOptimizer,
                                    populationSizeForGeneticOptimizer, benchmark,
                                    startDate, endDate, 0.0,
                                   	inSamplePortfolioType, maxRunningHours)
		{
      this.ScriptName = "PVO_SR_WithWeights_PriceSel";
      this.minLevelForOversoldThreshold  = minLevelForOversoldThreshold;
      this.maxLevelForOversoldThreshold = maxLevelForOversoldThreshold;
      this.minLevelForOverboughtThreshold = minLevelForOverboughtThreshold;
      this.maxLevelForOverboughtThreshold = maxLevelForOverboughtThreshold;
      this.divisorForThresholdComputation = divisorForThresholdComputation;
      this.symmetricalThresholds = symmetricalThresholds;
      this.overboughtMoreThanOversoldForFixedPortfolio = overboughtMoreThanOversoldForFixedPortfolio;
      this.maxAcceptableCloseToCloseDrawdown = maxAcceptableCloseToCloseDrawdown;
      this.numDaysForOscillatingPeriod = numDaysForOscillatingPeriod;
      this.numDaysBetweenEachOptimization = numDaysBetweenEachOptimization;
		}

    #region auxiliary overriden methods for Run

    protected override void run_initializeEndOfDayTimerHandler()
    {
      this.endOfDayTimerHandler = new EndOfDayTimerHandlerWeightedPVO(this.tickerGroupID, this.numberOfEligibleTickers,
    	                                                        this.numberOfTickersToBeChosen, this.numDaysForOptimizationPeriod,
                                                              this.account,
    	                                                        this.generationNumberForGeneticOptimizer,
    	                                                        this.populationSizeForGeneticOptimizer, this.benchmark,
    	                                                        this.numDaysForOscillatingPeriod,
    	                                                        this.minLevelForOversoldThreshold,
                                                              this.maxLevelForOversoldThreshold,
                                                              this.minLevelForOverboughtThreshold,
                                                              this.maxLevelForOverboughtThreshold,
                                                              this.divisorForThresholdComputation,
                                                              this.symmetricalThresholds,
                                                              this.overboughtMoreThanOversoldForFixedPortfolio,
    	                                                        this.numDaysBetweenEachOptimization,
                                                              this.portfolioType, this.maxAcceptableCloseToCloseDrawdown);
    }

    protected override void run_initializeHistoricalQuoteProvider()
    {
    	this.historicalQuoteProvider = new HistoricalAdjustedQuoteProvider();
    }

    protected override void run_addEventHandlers()
    {

      this.endOfDayTimer.MarketClose +=
        new MarketCloseEventHandler(
        this.endOfDayTimerHandler.MarketCloseEventHandler);

      this.endOfDayTimer.MarketClose +=
        new MarketCloseEventHandler(
        this.checkDateForReport);

      this.endOfDayTimer.OneHourAfterMarketClose += 
      	new OneHourAfterMarketCloseEventHandler(
      	   this.endOfDayTimerHandler.OneHourAfterMarketCloseEventHandler);
    }

    public override void SaveScriptResults()
    {
    	string fileName = DateTime.Now.Hour.ToString().PadLeft(2,'0') + "_" + 
    										DateTime.Now.Minute.ToString().PadLeft(2,'0') + "_" +
    		        				this.scriptName +  "OsDays_" + numDaysForOscillatingPeriod +
      								"_From_" + this.tickerGroupID + "_" + this.numberOfEligibleTickers +
                      "_DaysForOpt" + this.numDaysForOptimizationPeriod + "Tick" +
                      this.numberOfTickersToBeChosen + "GenN°" + 
                      this.generationNumberForGeneticOptimizer +
                      "PopSize" + this.populationSizeForGeneticOptimizer +
        							Convert.ToString(this.portfolioType);
      string dirNameWhereToSaveReports = System.Configuration.ConfigurationSettings.AppSettings["ReportsArchive"] +
                         								"\\" + this.ScriptName + "\\";
      string dirNameWhereToSaveTransactions = System.Configuration.ConfigurationSettings.AppSettings["TransactionsArchive"] +
                       									"\\" + this.ScriptName + "\\";
      string dirNameWhereToSaveBestGenomes = System.Configuration.ConfigurationSettings.AppSettings["GenomesArchive"] +
                                        "\\" + this.ScriptName + "\\";

      this.checkDateForReport_createDirIfNotPresent(dirNameWhereToSaveBestGenomes);
      OptimizationOutput optimizationOutput = new OptimizationOutput();
      foreach(GenomeRepresentation genomeRepresentation in this.endOfDayTimerHandler.BestGenomes)
      		optimizationOutput.Add(genomeRepresentation);
      ObjectArchiver.Archive(optimizationOutput,
                              dirNameWhereToSaveBestGenomes + 
                              fileName + ".bgn");

      //default report with numIntervalDays = 1
      AccountReport accountReport = this.account.CreateReport(fileName,1,
                                    		this.endOfDayTimer.GetCurrentTime(),
                                    		this.benchmark,
                                        new HistoricalAdjustedQuoteProvider());
      this.checkDateForReport_createDirIfNotPresent(dirNameWhereToSaveReports);
      ObjectArchiver.Archive(accountReport,
                             dirNameWhereToSaveReports + 
                             fileName + ".qPr");

      this.endOfDayTimer.Stop();

    }

    #endregion 
	}
}

--- NEW FILE: GenomeManagerWeightedPVO.cs ---
/*
QuantProject - Quantitative Finance Library

GenomeManagerWeightedPVO.cs
Copyright (C) 2003 
Marco Milletti

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Data;
using System.Collections;
using QuantProject.ADT;
using QuantProject.ADT.Statistics;
using QuantProject.ADT.Optimizing.Genetic;
using QuantProject.Data;
using QuantProject.Data.DataTables;
using QuantProject.Scripts.TickerSelectionTesting.EfficientPortfolios;
using QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator;

namespace QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator.WeightedPVO
{
	/// <summary>
	/// Implements what needed to use the Genetic Optimizer
	/// for finding the portfolio that best suites
	/// the Portfolio Value Oscillator strategy
	/// </summary>
	[Serializable]
  public class GenomeManagerWeightedPVO : GenomeManagerForEfficientPortfolio
  {
    protected int minLevelForOversoldThreshold;
    protected int maxLevelForOversoldThreshold;
    protected int minLevelForOverboughtThreshold;
    protected int maxLevelForOverboughtThreshold;
    protected int divisorForThresholdComputation;
    protected bool symmetricalThresholds = false;
    protected bool overboughtMoreThanOversoldForFixedPortfolio = false;
    protected int numOfGenesDedicatedToThresholds;
   	protected double currentOversoldThreshold = 0.0;
    protected double currentOverboughtThreshold = 0.0;
    protected int numDaysForOscillatingPeriod;
    protected int[] genePositionsPointingToTickers;

    protected double[] portfolioValues;//the values for each unit, invested
                                     //at the beginning of the optimization period,
    																//throughout the period itself

    protected bool genePositionPointsToATicker(int genePosition)
    {
      return ( genePosition >= this.numOfGenesDedicatedToThresholds &&
    	        ( (this.numOfGenesDedicatedToThresholds == 1 && genePosition%2 == 0) ||
    	          (this.numOfGenesDedicatedToThresholds == 2 && genePosition%2 != 0)   )   );
    }

    protected bool genePositionPointsToAWeight(int genePosition)
    {
      return ( genePosition >= this.numOfGenesDedicatedToThresholds &&
    	        ( (this.numOfGenesDedicatedToThresholds == 1 && genePosition%2 != 0) ||
    	          (this.numOfGenesDedicatedToThresholds == 2 && genePosition%2 == 0)   )   );
    }

    protected bool genePositionPointsToATreshold(int genePosition)
    {
    	return ( genePosition < this.numOfGenesDedicatedToThresholds );
    }

    public int[] GetGenePositionsPointingToTickers(Genome genome)
    {
    	int i = 0;
    	for(int genePosition = this.numOfGenesDedicatedToThresholds;
    	    genePosition < genome.Size;
    	    genePosition++)
    	{
    		if(this.genePositionPointsToATicker(genePosition) )
    		{
    			this.genePositionsPointingToTickers[i] = genePosition;
    			i++;
    		}
    	}
    	return this.genePositionsPointingToTickers;
    }

    private void genomeManagerWeightedPVO_checkParametersForThresholdsComputation()
    {
      if(this.maxLevelForOverboughtThreshold < this.minLevelForOverboughtThreshold || 
         this.maxLevelForOversoldThreshold < this.minLevelForOversoldThreshold ||
         this.divisorForThresholdComputation < this.maxLevelForOverboughtThreshold ||
         this.divisorForThresholdComputation < this.maxLevelForOversoldThreshold ||
         (this.symmetricalThresholds && (this.minLevelForOversoldThreshold != this.minLevelForOverboughtThreshold ||
                                        this.maxLevelForOversoldThreshold != this.maxLevelForOverboughtThreshold) ) ||
         (this.overboughtMoreThanOversoldForFixedPortfolio && 
            (this.minLevelForOverboughtThreshold > Convert.ToInt32(Convert.ToDouble(this.minLevelForOversoldThreshold)* Convert.ToDouble(this.divisorForThresholdComputation) /
                                                     (Convert.ToDouble(this.divisorForThresholdComputation) - Convert.ToDouble(this.minLevelForOversoldThreshold) ) )  ||
              this.maxLevelForOverboughtThreshold < Convert.ToInt32(Convert.ToDouble(this.maxLevelForOversoldThreshold) * Convert.ToDouble(this.divisorForThresholdComputation) /
                                                     (Convert.ToDouble(this.divisorForThresholdComputation) - Convert.ToDouble(this.maxLevelForOversoldThreshold) ) ) ) ) ) 

          throw new Exception("Bad parameters for thresholds computation!");
    }

    public GenomeManagerWeightedPVO(DataTable setOfInitialTickers,
                           DateTime firstQuoteDate,
                           DateTime lastQuoteDate,
                           int numberOfTickersInPortfolio,
                           int numDaysForOscillatingPeriod,
                           int minLevelForOversoldThreshold,
	                         int maxLevelForOversoldThreshold,
	                         int minLevelForOverboughtThreshold,
	                         int maxLevelForOverboughtThreshold,
                           int divisorForThresholdComputation,
                           bool symmetricalThresholds,
                           bool overboughtMoreThanOversoldForFixedPortfolio,
                           PortfolioType inSamplePortfolioType)
                           :
                          base(setOfInitialTickers,
                          firstQuoteDate,
                          lastQuoteDate,
                          numberOfTickersInPortfolio,
                          0.0,
                          inSamplePortfolioType)

    {
    	this.numDaysForOscillatingPeriod = numDaysForOscillatingPeriod;
    	this.divisorForThresholdComputation = divisorForThresholdComputation;
			this.minLevelForOversoldThreshold  = minLevelForOversoldThreshold;
      this.maxLevelForOversoldThreshold = maxLevelForOversoldThreshold;
      this.minLevelForOverboughtThreshold = minLevelForOverboughtThreshold;
      this.maxLevelForOverboughtThreshold = maxLevelForOverboughtThreshold;
      this.symmetricalThresholds = symmetricalThresholds;
      this.overboughtMoreThanOversoldForFixedPortfolio = overboughtMoreThanOversoldForFixedPortfolio;
      if(this.symmetricalThresholds)//value for thresholds must be unique
 				numOfGenesDedicatedToThresholds = 1;
      else
      	numOfGenesDedicatedToThresholds = 2;
      this.genePositionsPointingToTickers = new int[(this.GenomeSize - this.numOfGenesDedicatedToThresholds)/2];
      this.genomeManagerWeightedPVO_checkParametersForThresholdsComputation();
      this.retrieveData();
    }

    public override int GenomeSize
    {
      get{return this.genomeSize * 2
    			+ this.numOfGenesDedicatedToThresholds;}
    }

    #region Get Min and Max Value

    private int getMinValueForGenes_getMinValueForTicker()
    {
      int returnValue;
      switch (this.portfolioType)
      {
        case PortfolioType.OnlyLong :
          returnValue = 0;
          break;
        default://For ShortAndLong or OnlyShort portfolios
          returnValue = - this.originalNumOfTickers;
          break;
      }
      return returnValue;
    }

    public override int GetMinValueForGenes(int genePosition)
    {
    	int returnValue;
    	switch (genePosition)
    	{
    		case 0 ://gene for oversold threshold
					returnValue = this.minLevelForOversoldThreshold;
					break;
				case 1 ://gene for overbought threshold if thresholds are asymmetrical
					if(this.numOfGenesDedicatedToThresholds == 2)
						returnValue = this.minLevelForOverboughtThreshold;
					else
            returnValue = this.getMinValueForGenes_getMinValueForTicker();
				  break;
				default://gene for ticker or weight
					returnValue = this.getMinValueForGenes_getMinValueForTicker();
					break;
      }
    	return returnValue;
    }

    private int getMaxValueForGenes_getMaxValueForTicker()
    {
      int returnValue;
      switch (this.portfolioType)
      {
        case PortfolioType.OnlyShort :
          returnValue = - 1;
          break;
        default ://For ShortAndLong or OnlyLong portfolios
          returnValue = this.originalNumOfTickers - 1;
          break;
      }
      return returnValue;
    }

    public override int GetMaxValueForGenes(int genePosition)
    {
      int returnValue;
    	switch (genePosition)
    	{
    		case 0 ://gene for oversold threshold
					returnValue = this.maxLevelForOversoldThreshold;
					break;
				case 1 ://gene for overbought threshold when thresholds are asymmetrical
					if(this.numOfGenesDedicatedToThresholds == 2)
						returnValue = this.maxLevelForOverboughtThreshold;
					else
						returnValue = this.getMaxValueForGenes_getMaxValueForTicker();
					break;
				default://gene for ticker
					returnValue = this.getMaxValueForGenes_getMaxValueForTicker();
					break;
      }
    	return returnValue;
    }																

    #endregion

    protected override float[] getArrayOfRatesOfReturn(string ticker)
    {
      float[] returnValue = null;
      Quotes tickerQuotes = new Quotes(ticker, this.firstQuoteDate, this.lastQuoteDate);
      tickerQuotes.RecalculateCloseToCloseRatios();
      returnValue = QuantProject.ADT.ExtendedDataTable.GetArrayOfFloatFromColumn(tickerQuotes,
    	                                                          Quotes.AdjustedCloseToCloseRatio);
      for(int i = 0; i<returnValue.Length; i++)
        returnValue[i] = returnValue[i] - 1.0f;

      this.numberOfExaminedReturns = returnValue.Length;

      return returnValue;
    }
    //starting from this.numDaysForOscillatingPeriod day,
    //it computes for each day ahead the value of the
    //portfolio opened numDaysForOscillatingPeriod days ago
    private double[] getPortfolioMovingValues()
    {
    	double[] returnV...

[truncated message content]

Thread: [Quantproject-developers] QuantProject/b7_Scripts/TechnicalAnalysisTesting/Oscillators/FixedLevelOs

quantproject-developers