[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
In directory sc8-pr-cvs16.sourceforge.net:/tmp/cvs-serv23698/b7_Scripts/TechnicalAnalysisTesting/Oscillators/FixedLevelOscillators/PortfolioValueOscillator

Added Files:
	PVO_CTOLogItem.cs PVO_CTOMain.cs PVO_CTOStrategy.cs 
Log Message:
Added PVO_CTO strategy (PVO by night)

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

PVO_CTOLogItem.cs
Copyright (C) 2008
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 QuantProject.Business.DataProviders;
using QuantProject.Business.Strategies;
using QuantProject.Business.Financial.Accounting.AccountProviding;
using QuantProject.Business.Strategies.Eligibles;
using QuantProject.Business.Strategies.InSample;
using QuantProject.Business.Strategies.OutOfSample;
using QuantProject.Business.Strategies.Logging;
using QuantProject.Business.Strategies.ReturnsManagement.Time;
using QuantProject.Business.Strategies.ReturnsManagement.Time.IntervalsSelectors;
using QuantProject.Business.Timing;
using QuantProject.Scripts.General.Reporting;

namespace QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator
{
  /// <summary>
  /// LogItem for the PVO_CTO strategy
  /// portfolio value oscillator strategy
  /// </summary>
  [Serializable]
  public class PVO_CTOLogItem : PVOLogItem
  {

		public PVO_CTOLogItem(EndOfDayDateTime endOfDayDateTime,
  	                      int numberOfInSampleDays)
			: base( endOfDayDateTime , numberOfInSampleDays )
		{

		}

		protected override void runStrategyClickEventHandler(object sender, System.EventArgs e)
		{
			//general
			int inSampleDays = 90;
			DateTime firstDateTime = this.SimulatedCreationTime.DateTime.AddDays(-inSampleDays);
			DateTime lastDateTime = this.SimulatedCreationTime.DateTime;
			double maxRunningHours = 1;
			Benchmark benchmark = new Benchmark( "^GSPC" );
			// definition for the Fitness Evaluator (for
			// objects that use it)
			int	numberOfPortfolioPositions =
				this.BestPVOPositionsInSample[0].WeightedPositions.Count;
			//cash and portfolio type
			double cashToStart = 25000;

			HistoricalQuoteProvider historicalQuoteProviderForBackTester,
				historicalQuoteProviderForInSampleChooser,
				historicalQuoteProviderForStrategy;
			historicalQuoteProviderForBackTester =
				new HistoricalAdjustedQuoteProvider();
			historicalQuoteProviderForInSampleChooser = historicalQuoteProviderForBackTester;
			historicalQuoteProviderForStrategy = historicalQuoteProviderForInSampleChooser;

			IEligiblesSelector eligiblesSelector =
				new DummyEligibleSelector();
			//strategyParameters
			TestingPositions[] positionsToTest =
				new TestingPositions[this.bestPVOPositionsInSample.Length];
			positionsToTest = this.bestPVOPositionsInSample;
			PVO_CTOStrategy strategy =
				new PVO_CTOStrategy(eligiblesSelector,
				positionsToTest, inSampleDays,
				benchmark ,
				int.MaxValue ,
				0 ,
				((PVOPositions)positionsToTest[0]).OversoldThreshold,
				((PVOPositions)positionsToTest[0]).OverboughtThreshold,
				historicalQuoteProviderForStrategy);

			EndOfDayStrategyBackTester endOfDayStrategyBackTester =
				new EndOfDayStrategyBackTester(
				"PVO_CTO" , strategy ,
				historicalQuoteProviderForBackTester , 
				new SimpleAccountProvider(),
				firstDateTime ,
				lastDateTime , benchmark , cashToStart , maxRunningHours );

			// TO DO check if you can do this assign in the EndOfDayStrategyBackTester
			// constructor
			strategy.Account = endOfDayStrategyBackTester.Account;
			endOfDayStrategyBackTester.Run();
			BackTesterReportViewer.ShowReport( lastDateTime ,
				endOfDayStrategyBackTester );
		}
	}
}

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

PVO_CTOMain.cs
Copyright (C) 2008
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.IO;

using QuantProject.ADT;
using QuantProject.ADT.FileManaging;
using QuantProject.Business.DataProviders;
using QuantProject.Business.Strategies;
using QuantProject.Business.Financial.Accounting.AccountProviding;
using QuantProject.Business.Strategies.Eligibles;
using QuantProject.Business.Strategies.EquityEvaluation;
using QuantProject.Business.Strategies.InSample;
using QuantProject.Business.Strategies.Logging;
using QuantProject.Business.Strategies.Optimizing.Decoding;
using QuantProject.Business.Strategies.Optimizing.FitnessEvaluation;
using QuantProject.Business.Strategies.ReturnsManagement;
using QuantProject.Business.Strategies.ReturnsManagement.Time;
using QuantProject.Business.Strategies.ReturnsManagement.Time.IntervalsSelectors;
using QuantProject.Business.Timing;
using QuantProject.Presentation;
using QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator.InSampleChoosers;
using QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator.Decoding;
using QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator.FitnessEvaluators;
using QuantProject.Scripts.General;
using QuantProject.Scripts.General.Logging;
using QuantProject.Scripts.General.Reporting;

namespace QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator
{
	/// <summary>
	/// Entry point for the PVO_OTC strategy. If any strategy
	/// parameter had to be changed, this is the place where it should
	/// be done
	/// </summary>
	public class PVO_CTOMain : BasicScriptForBacktesting
	{
		private Benchmark benchmark;
		private HistoricalQuoteProvider historicalQuoteProvider;

		public PVO_CTOMain()
		{
			this.benchmark = new Benchmark( "BMC" );

			this.historicalQuoteProvider =
				new HistoricalAdjustedQuoteProvider();

			// definition for the Fitness Evaluator
			//      IEquityEvaluator equityEvaluator = new SharpeRatio();
		}

		protected override IEligiblesSelector getEligiblesSelector()
		{

			int maxNumberOfEligiblesToBeChosen = 100;

			string tickersGroupId = "SP500";

			bool temporizedGroup = true;
			int numDaysForAverageRawOpenPriceComputation = 10;
			double minPrice = 30;
			double maxPrice = 75;

			int maxNumberOfMostLiquidTickersToBeChosen = 150;
			int numDaysForVolatility = 10;
			IEligiblesSelector eligiblesSelector =
				new ByPriceMostLiquidLessVolatileCTOAlwaysQuoted(
				tickersGroupId , temporizedGroup ,
				maxNumberOfEligiblesToBeChosen ,
				maxNumberOfMostLiquidTickersToBeChosen ,
			  numDaysForAverageRawOpenPriceComputation ,
				numDaysForVolatility ,
			 	minPrice , maxPrice );
//			IEligiblesSelector eligiblesSelector =
//				new ByPriceMostLiquidAlwaysQuoted(
//				tickersGroupId , temporizedGroup ,
//				maxNumberOfEligiblesToBeChosen ,
//			  numDaysForAverageRawOpenPriceComputation ,
//			 	minPrice , maxPrice );
//			IEligiblesSelector eligiblesSelector =
//				new ByPriceLessVolatileOTCAlwaysQuoted(
//				tickersGroupId , temporizedGroup ,
//				maxNumberOfEligiblesToBeChosen ,
//			  numDaysForAverageRawOpenPriceComputation ,
//			 	minPrice , maxPrice );
			eligiblesSelector = 
				new DummyEligibleSelector();
//			
			return eligiblesSelector;
		}

		protected override IInSampleChooser getInSampleChooser()
		{
			// parameters for the genetic optimizer
//			double crossoverRate = 0.85;
//			double mutationRate = 0.02;
//			double elitismRate = 0.001;
//			int populationSizeForGeneticOptimizer = 3000;
//			int generationNumberForGeneticOptimizer = 4;
//			int seedForRandomGenerator =
//				QuantProject.ADT.ConstantsProvider.SeedForRandomGenerator;

//			IDecoderForTestingPositions decoderForWeightedPositions =
//				new DecoderForPairsTradingTestingPositionsWithBalancedWeights();

			double maxCorrelationAllowed = 0.96;
			int numberOfBestTestingPositionsToBeReturned = 100;
			numberOfBestTestingPositionsToBeReturned = 100;
			bool balancedWeightsOnVolatilityBase = true;
			int returnIntervalLength = 1;
			float minimumAbsoluteReturnValue = 0.000001f;
			float maximumAbsoluteReturnValue = 100000f;
			//correlation is computed only for returns
			//between minimum and maximum
			IInSampleChooser inSampleChooser = 
				new PVO_CTCCorrelationChooser(numberOfBestTestingPositionsToBeReturned, 
						returnIntervalLength, maxCorrelationAllowed , balancedWeightsOnVolatilityBase,
					  minimumAbsoluteReturnValue , maximumAbsoluteReturnValue, this.benchmark.Ticker);
//			IInSampleChooser inSampleChooser = 
//					new PVO_OTOCorrelationChooser(numberOfBestTestingPositionsToBeReturned, 
//							returnIntervalLength, maxCorrelationAllowed , balancedWeightsOnVolatilityBase,
//						  minimumAbsoluteReturnValue , maximumAbsoluteReturnValue);

//			IInSampleChooser inSampleChooser =
//				new PVO_OTCCorrelationChooser(numberOfBestTestingPositionsToBeReturned, 
//						maxCorrelationAllowed , balancedWeightsOnVolatilityBase,
//					  minimumAbsoluteReturnValue , maximumAbsoluteReturnValue);
//			IInSampleChooser inSampleChooser =
//				new PVO_CTOCorrelationChooser(numberOfBestTestingPositionsToBeReturned, 
//						maxCorrelationAllowed , balancedWeightsOnVolatilityBase,
//					  minimumAbsoluteReturnValue , maximumAbsoluteReturnValue);

//			IInSampleChooser inSampleChooser =
//				new PVO_OTCCTOCorrelationChooser(numberOfBestTestingPositionsToBeReturned, 
//						maxCorrelationAllowed , balancedWeightsOnVolatilityBase,
//					  minimumAbsoluteReturnValue , maximumAbsoluteReturnValue);
//			//office
//			inSampleChooser =
//				new PVOChooserFromSavedBackTestLog(
//					@"C:\Utente\MarcoVarie\Vari\qP\LogArchive\2008_05_02_15_55_32_PVO_OTC_from_2001_01_01_to_2008_04_28_annlRtrn_101,19_maxDD_6,30\2008_05_02_15_55_32_PVO_OTC_from_2001_01_01_to_2008_04_28_annlRtrn_101,19_maxDD_6,30.qpL",
//				  numberOfBestTestingPositionsToBeReturned);

			//office - CTO
//			inSampleChooser =
//				new PVOChooserFromSavedBackTestLog(
//					@"C:\Utente\MarcoVarie\Vari\qP\LogArchive\2008_05_14_10_12_30_PVO_CTO_from_2001_01_01_to_2004_12_31_annlRtrn_16,08_maxDD_8,34\2008_05_14_10_12_30_PVO_CTO_from_2001_01_01_to_2004_12_31_annlRtrn_16,08_maxDD_8,34.qpL",
//				  numberOfBestTestingPositionsToBeReturned);

			//home
			inSampleChooser =
				new PVOChooserFromSavedBackTestLog(
				@"C:\Utente\MarcoVarie\Vari\qP\LogArchive\2008_05_18_12_13_22_PVO_CTO_from_2006_01_01_to_2008_04_28_annlRtrn_4.15_maxDD_17.07\2008_05_18_12_13_22_PVO_CTO_from_2006_01_01_to_2008_04_28_annlRtrn_4.15_maxDD_17.07.qpL",
				numberOfBestTestingPositionsToBeReturned);
			return inSampleChooser;
		}

		protected override IEndOfDayStrategyForBacktester getEndOfDayStrategy()
		{
			int inSampleDays = 180;
			// uncomment the following line for a faster script
			//inSampleDays = 50;
			int numDaysBetweenEachOptimization = 5;
			int numOfClosingsBeforeExit = 0;
			int minNumOfEligiblesForValidOptimization = 10;
			double oversoldThreshold = 0.007;
			double overboughtThreshold = 0.007;
			double oversoldThresholdMAX = 0.02;
			double overboughtThresholdMAX = 0.02;
			IEndOfDayStrategyForBacktester endOfDayStrategy
				= new PVO_OTCStrategy(eligiblesSelector ,
				minNumOfEligiblesForValidOptimization, inSampleChooser ,
				inSampleDays , benchmark , numDaysBetweenEachOptimization ,
				numOfClosingsBeforeExit, oversoldThreshold , overboughtThreshold ,
				oversoldThresholdMAX , overboughtThresholdMAX , historicalQuoteProvider);
			return endOfDayStrategy;
		}
		protected override EndOfDayStrategyBackTester getEndOfDayStrategyBackTester()
		{
			string backTestId = "PVO_CTO";
			IAccountProvider accountProvider;
			accountProvider =	new SimpleAccountProvider();
//			double fixedPercentageSlippage = 0.05;
//			accountProvider =
//				new InteractiveBrokerAccountProvider(fixedPercentageSlippage);
			double cashToStart = 25000;

			DateTime firstDateTime = new DateTime( 2006 , 1 , 1 );
			DateTime lastDateTime = new DateTime( 2008 , 4, 28 );
			double maxRunningHours = 3;
			HistoricalQuoteProvider quoteProviderForBackTester =
				this.historicalQuoteProvider;
			quoteProviderForBackTester =
				new HistoricalAdjustedQuoteProvider();
			EndOfDayStrategyBackTester endOfDayStrategyBackTester =
				new EndOfDayStrategyBackTester(
				backTestId , this.endOfDayStrategy ,
				quoteProviderForBackTester , accountProvider ,
				firstDateTime ,	lastDateTime ,
				this.benchmark , cashToStart , maxRunningHours );
			return endOfDayStrategyBackTester;
		}

		protected override string getPathForTheMainFolderWhereScriptsResultsAreToBeSaved()
		{
			string pathForTheMainFolderWhereScriptsResultsAreToBeSaved =
				System.Configuration.ConfigurationSettings.AppSettings["LogArchive"];
			return pathForTheMainFolderWhereScriptsResultsAreToBeSaved;
		}

		protected override string getCustomSmallTextForFolderName()
		{
			return "PVO_CTO";
		}

		protected override string getFullPathFileNameForMain()
		{
			string returnValue;
			string fullPathFileNameForMainAtHome = 
				@"C:\Quant\QuantProject\b7_Scripts\TechnicalAnalysisTesting\Oscillators\FixedLevelOscillators\PortfolioValueOscillator\PVO_CTOMain.cs";
			if( File.Exists(fullPathFileNameForMainAtHome) )
				returnValue = fullPathFileNameForMainAtHome;
			else
				returnValue = 
					@"C:\Utente\MarcoVarie\Vari\qP\QuantProject\b7_Scripts\TechnicalAnalysisTesting\Oscillators\FixedLevelOscillators\PortfolioValueOscillator\PVO_CTOMain.cs";

			return returnValue;
		}
	}
}

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

PVO_CTOStrategy.cs
Copyright (C) 2008 
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.Messaging;
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.Business.Strategies.InSample;
using QuantProject.Business.Strategies.OutOfSample;
using QuantProject.Business.Strategies.Logging;
using QuantProject.Business.Strategies.ReturnsManagement;
using QuantProject.Business.Strategies.ReturnsManagement.Time;
using QuantProject.Business.DataProviders;
using QuantProject.Business.Strategies.TickersRelationships;
using QuantProject.Business.Strategies.Eligibles;
using QuantProject.Business.Strategies.Optimizing.Decoding;
using QuantProject.Data;
using QuantProject.Data.DataProviders;
using QuantProject.Data.Selectors;
using QuantProject.Data.DataTables;
using QuantProject.ADT.Optimizing.Genetic;
using QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator.InSampleChoosers;
using QuantProject.Scripts.TickerSelectionTesting.EfficientPortfolios;
using QuantProject.Scripts.WalkForwardTesting.LinearCombination;

namespace QuantProject.Scripts.TechnicalAnalysisTesting.Oscillators.FixedLevelOscillators.PortfolioValueOscillator
{
	/// <summary>
  /// Implements MarketOpenEventHandler and MarketCloseEventHandler
  /// These handlers contain the core strategy for the Portfolio Value
  /// Oscillator
  /// </summary>
  [Serializable]
  public class PVO_CTOStrategy : IEndOfDayStrategyForBacktester
  {
		public event NewLogItemEventHandler NewLogItem;
		public event NewMessageEventHandler NewMessage;

		//initialized by the constructor
  	protected int inSampleDays;
    protected int numDaysBetweenEachOptimization;
    protected IInSampleChooser inSampleChooser;
    protected IEligiblesSelector eligiblesSelector;
    protected Benchmark benchmark;
    protected HistoricalQuoteProvider historicalQuoteProvider;
    protected double oversoldThreshold;
    protected double overboughtThreshold;
    protected double oversoldThresholdMAX;
    protected double overboughtThresholdMAX;
    //initialized after constructor's call
    protected int numDaysElapsedSinceLastOptimization;
    protected ReturnsManager returnsManager;
		protected TestingPositions[] chosenPVOPositions;
		//chosen in sample: these are the eligible positions for out
		//of sample testing
		protected PVOPositions pvoPositionsForOutOfSample;
    protected DateTime lastCloseDate;
		protected DateTime lastOptimizationDateTime;
    protected Account account;
    public Account Account
		{
    	get { return this.account; }
    	set { this.account = value; }
		}
    private int numOfOpeningsToCrossBeforeExit;
    private int numOfOpeningsWithOpenPositions;

    private string description_GetDescriptionForChooser()
    {
    	if(this.inSampleChooser == null)
    		return "ConstantChooser";
    	else
    		return this.inSampleChooser.Description;	
    }

		public string Description
		{
			get
			{
				string description =
					"PVO_CTO\n" +
					"Tickers_" + "2\n" +
					"_inSampleDays_" + this.inSampleDays.ToString() + "\n" +
					this.eligiblesSelector.Description + "\n" +
					"oversoldThreshold_" + this.oversoldThreshold.ToString() + "\n" +
					"overboughtThreshold_" + this.overboughtThreshold.ToString() + "\n" +
					this.description_GetDescriptionForChooser() + "\n" +
					"Optimization each " + this.numDaysBetweenEachOptimization.ToString() + " days";
				return description;
			}
		}

		public bool StopBacktestIfMaxRunningHoursHasBeenReached
		{
			get
			{
				return true;
			}
		}

		private void pvo_ctoStrategy(IEligiblesSelector eligiblesSelector,
			int inSampleDays,
			Benchmark benchmark,
			int numDaysBetweenEachOptimization,
			int numOfOpeningsToCrossBeforeExit,
			double oversoldThreshold,
			double overboughtThreshold,
			double oversoldThresholdMAX,
			double overboughtThresholdMAX,
			HistoricalQuoteProvider historicalQuoteProvider)
		{
			this.numOfOpeningsWithOpenPositions = 0;
			this.eligiblesSelector = eligiblesSelector;
			this.inSampleDays = inSampleDays;
			this.benchmark = benchmark;
			this.numDaysBetweenEachOptimization = numDaysBetweenEachOptimization;
			this.numOfOpeningsToCrossBeforeExit = numOfOpeningsToCrossBeforeExit;
			this.oversoldThreshold = oversoldThreshold;
			this.overboughtThreshold = overboughtThreshold;
			this.oversoldThresholdMAX = oversoldThresholdMAX;
			this.overboughtThresholdMAX = overboughtThresholdMAX;
			this.historicalQuoteProvider = historicalQuoteProvider;
		}

    public PVO_CTOStrategy(IEligiblesSelector eligiblesSelector,
																IInSampleChooser inSampleChooser,
																int inSampleDays,
																Benchmark benchmark,
																int numDaysBetweenEachOptimization,
																int numOfOpeningsToCrossBeforeExit,
																double oversoldThreshold,
																double overboughtThreshold,
																double oversoldThresholdMAX,
																double overboughtThresholdMAX,
                                HistoricalQuoteProvider historicalQuoteProvider)

    {
			this.pvo_ctoStrategy(eligiblesSelector, inSampleDays , benchmark , numDaysBetweenEachOptimization ,
				numOfOpeningsToCrossBeforeExit, oversoldThreshold, overboughtThreshold,
				oversoldThresholdMAX, overboughtThresholdMAX,
				historicalQuoteProvider);
			this.inSampleChooser = inSampleChooser;
    }

		public PVO_CTOStrategy(IEligiblesSelector eligiblesSelector,
																IInSampleChooser inSampleChooser,
																int inSampleDays,
																Benchmark benchmark,
																int numDaysBetweenEachOptimization,
																int numOfOpeningsToCrossBeforeExit,
																double oversoldThreshold,
																double overboughtThreshold,
                                HistoricalQuoteProvider historicalQuoteProvider)

    {
			this.pvo_ctoStrategy(eligiblesSelector, inSampleDays , benchmark , numDaysBetweenEachOptimization ,
				numOfOpeningsToCrossBeforeExit, oversoldThreshold, overboughtThreshold,
				double.MaxValue, double.MaxValue,
				historicalQuoteProvider);
			this.inSampleChooser = inSampleChooser;
    }
		public PVO_CTOStrategy(IEligiblesSelector eligiblesSelector,
			TestingPositions[] chosenPVOPositions,
			int inSampleDays,
			Benchmark benchmark,
			int numDaysBetweenEachOptimization,
			int numOfOpeningsToCrossBeforeExit,
			double oversoldThreshold,
			double overboughtThreshold,
			double oversoldThresholdMAX,
			double overboughtThresholdMAX,
			HistoricalQuoteProvider historicalQuoteProvider)

		{
			this.pvo_ctoStrategy(eligiblesSelector, inSampleDays , benchmark , numDaysBetweenEachOptimization ,
				numOfOpeningsToCrossBeforeExit,
				oversoldThreshold, overboughtThreshold,
				oversoldThresholdMAX, overboughtThresholdMAX,
				historicalQuoteProvider);
			this.chosenPVOPositions = chosenPVOPositions;
		}
		public PVO_CTOStrategy(IEligiblesSelector eligiblesSelector,
			TestingPositions[] chosenPVOPositions,
			int inSampleDays,
			Benchmark benchmark,
			int numDaysBetweenEachOptimization,
			int numOfOpeningsToCrossBeforeExit,
			double oversoldThreshold,
			double overboughtThreshold,
			HistoricalQuoteProvider historicalQuoteProvider)

		{
			this.pvo_ctoStrategy(eligiblesSelector, inSampleDays , benchmark , numDaysBetweenEachOptimization ,
				numOfOpeningsToCrossBeforeExit,
				oversoldThreshold, overboughtThreshold,
				double.MaxValue, double.MaxValue,
				historicalQuoteProvider);
			this.chosenPVOPositions = chosenPVOPositions;
		}

		public virtual void MarketOpenEventHandler(
      Object sender , EndOfDayTimingEventArgs endOfDayTimingEventArgs )
    {
			if(this.account.Portfolio.Count > 0)
			{
				this.numOfOpeningsWithOpenPositions++;
				if(this.numOfOpeningsWithOpenPositions > this.numOfOpeningsToCrossBeforeExit)
				{
					AccountManager.ClosePositions(this.account);
					this.numOfOpeningsWithOpenPositions = 0;
				}
			}
    }

		public void FiveMinutesBeforeMarketCloseEventHandler(
			Object sender , EndOfDayTimingEventArgs endOfDayTimingEventArgs )
		{
		}

		private EndOfDayDateTime now()
		{
			return this.account.EndOfDayTimer.GetCurrentTime();
		}

		protected virtual EndOfDayDateTime getBeginOfOscillatingPeriod(IndexBasedEndOfDayTimer timer)
		{
			return new EndOfDayDateTime(	(DateTime)timer.IndexQuotes.Rows[timer.CurrentDateArrayPosition]["quDate"],
				EndOfDaySpecificTime.MarketOpen );
		}

		#region MarketCloseEventHandler

		private PVOPositionsStatus marketCloseEventHandler_openPositions_getStatus(IndexBasedEndOfDayTimer timer)
    {
    	EndOfDayDateTime today = timer.GetCurrentTime();
    	EndOfDayDateTime beginOfOscillatingPeriod =
    		this.getBeginOfOscillatingPeriod(timer);
    	PVOPositionsStatus currentStatus = 
    		PVOPositionsStatus.InTheMiddle;
    	for(int i = 0; i<this.chosenPVOPositions.Length; i++)
    	{
    		if(this.chosenPVOPositions[i] != null)
    			currentStatus = 
    				((PVOPositions)this.chosenPVOPositions[i]).GetStatus(beginOfOscillatingPeriod, today,
    				                                     this.benchmark.Ticker, this.historicalQuoteProvider,
    				                                     this.oversoldThresholdMAX, this.overboughtThresholdMAX);
    		if(currentStatus == PVOPositionsStatus.Oversold ||
    		   currentStatus == PVOPositionsStatus.Overbought )
    		{	
					this.pvoPositionsForOutOfSample = (PVOPositions)this.chosenPVOPositions[i];
					i = this.chosenPVOPositions.Length;//exit from for
				}
     	}
    		return currentStatus;
    }

		protected void marketCloseEventHandler_openPositions(IndexBasedEndOfDayTimer timer)
		{
			PVOPositionsStatus pvoPositionsStatus = PVOPositionsStatus.InTheMiddle;
			if(timer.CurrentDateArrayPosition >= 1)
				pvoPositionsStatus = 
					this.marketCloseEventHandler_openPositions_getStatus(timer);
			switch (pvoPositionsStatus)
			{
				case PVOPositionsStatus.Overbought:
				{
    			#region manage Overbought case
					this.pvoPositionsForOutOfSample.WeightedPositions.Reverse();
					try
					{
						AccountManager.OpenPositions( this.pvoPositionsForOutOfSample.WeightedPositions,
							this.account );
					}
					catch(Exception ex)
					{
						ex = ex;
					}
					finally
					{
						this.pvoPositionsForOutOfSample.WeightedPositions.Reverse();
					}
      		#endregion
					break;
				}
				case PVOPositionsStatus.Oversold:
				{
    			AccountManager.OpenPositions( this.pvoPositionsForOutOfSample.WeightedPositions,
						this.account );
					break;
				}
				case PVOPositionsStatus.InTheMiddle://that is
				{  //pvoPositionsForOutOfSample has not been set

					break;
				}
				default:
				{
					//it should never been reached
					break;
				}
			}
		}

    public virtual void MarketCloseEventHandler(
      Object sender , EndOfDayTimingEventArgs endOfDayTimingEventArgs )
    {
			if ( this.account.Portfolio.Count == 0 &&
					 this.chosenPVOPositions != null )
					//portfolio is empty and optimization has
				  //been already launched
			{
				try{
					this.marketCloseEventHandler_openPositions( (IndexBasedEndOfDayTimer)sender );
				}
				catch(TickerNotExchangedException ex)
				{ex=ex;}
			}
		}

		#endregion

    #region OneHourAfterMarketCloseEventHandler

		protected virtual void updateReturnsManager(EndOfDayDateTime firstEndOfDayDateTime,
			EndOfDayDateTime lastEndOfDayDateTime)
		{
			ReturnIntervals returnIntervals = 
				new CloseToOpenIntervals( firstEndOfDayDateTime, lastEndOfDayDateTime,
																	this.benchmark.Ticker );
			if( this.inSampleChooser is PVOCorrelationChooser )
			{
				switch ( ((PVOCorrelationChooser)this.inSampleChooser).IntervalsType )
				{
					case IntervalsType.CloseToCloseIntervals:
						returnIntervals = new CloseToCloseIntervals(firstEndOfDayDateTime, lastEndOfDayDateTime,
							this.benchmark.Ticker, ((PVOCorrelationChooser)this.inSampleChooser).ReturnIntervalLength);
						break;
					case IntervalsType.OpenToOpenIntervals:
						returnIntervals = new OpenToOpenIntervals(firstEndOfDayDateTime, lastEndOfDayDateTime,
							this.benchmark.Ticker, ((PVOCorrelationChooser)this.inSampleChooser).ReturnIntervalLength);
						break;
					case IntervalsType.CloseToOpenIntervals:
						returnIntervals = new CloseToOpenIntervals(firstEndOfDayDateTime, lastEndOfDayDateTime,
							this.benchmark.Ticker);
						break;
					case IntervalsType.OpenToCloseIntervals:
						returnIntervals = new DailyOpenToCloseIntervals(firstEndOfDayDateTime, lastEndOfDayDateTime,
							this.benchmark.Ticker );
						break;
					case IntervalsType.OpenToCloseCloseToOpenIntervals:
						returnIntervals = new OpenToCloseCloseToOpenIntervals(
							firstEndOfDayDateTime, lastEndOfDayDateTime, this.benchmark.Ticker);
						break;
					default:
						// it should never be reached
						returnIntervals = new DailyOpenToCloseIntervals(firstEndOfDayDateTime, lastEndOfDayDateTime,
							this.benchmark.Ticker );
						break;
				}
			}

			this.returnsManager =
					new ReturnsManager( returnIntervals , this.historicalQuoteProvider);	

		}

		private PVO_CTOLogItem getLogItem( EligibleTickers eligibleTickers )
		{
			PVO_CTOLogItem logItem =
				new PVO_CTOLogItem( this.now() , this.inSampleDays );
			logItem.BestPVOPositionsInSample =
				this.chosenPVOPositions;
			logItem.NumberOfEligibleTickers =
				eligibleTickers.Count;
			logItem.FitnessOfFirst = 
				this.chosenPVOPositions[0].FitnessInSample;
			logItem.FitnessOfLast = 
				this.chosenPVOPositions[this.chosenPVOPositions.Length - 1].FitnessInSample;
//			logItem.GenerationOfFirst = 
//				((IGeneticallyOptimizable)this.chosenPVOPositions[0]).Generation;
//			logItem.GenerationOfLast = 
//				((IGeneticallyOptimizable)this.chosenPVOPositions[this.chosenPVOPositions.Length - 1]).Generation;
			logItem.ThresholdsOfFirst = 
				((PVOPositions)this.chosenPVOPositions[0]).OversoldThreshold.ToString() + ";" +
				((PVOPositions)this.chosenPVOPositions[0]).OverboughtThreshold.ToString();
			logItem.ThresholdsOfLast = 
				((PVOPositions)this.chosenPVOPositions[this.chosenPVOPositions.Length - 1]).OversoldThreshold.ToString() + ";" +
				((PVOPositions)this.chosenPVOPositions[this.chosenPVOPositions.Length - 1]).OverboughtThreshold.ToString();
			logItem.TickersOfFirst = 
				this.chosenPVOPositions[0].HashCodeForTickerComposition;
			logItem.TickersOfLast = 
				this.chosenPVOPositions[this.chosenPVOPositions.Length - 1].HashCodeForTickerComposition;
			return logItem;
		}
		private void raiseNewLogItem( EligibleTickers eligibleTickers )
		{
			PVO_CTOLogItem logItem =
				this.getLogItem( eligibleTickers );
			NewLogItemEventArgs newLogItemEventArgs =
				new NewLogItemEventArgs( logItem );
			this.NewLogItem( this , newLogItemEventArgs );
		}
		private void notifyMessage( EligibleTickers eligibleTickers )
		{
			string message = "Number of Eligible tickers: " +
				eligibleTickers.Count;
			NewMessageEventArgs newMessageEventArgs =
				new NewMessageEventArgs( message );
			if ( this.NewMessage != null )
				this.NewMessage( this , newMessageEventArgs );
		}
		private void logOptimizationInfo( EligibleTickers eligibleTickers )
		{
			this.raiseNewLogItem( eligibleTickers );
			this.notifyMessage( eligibleTickers );
		}

		private void updateTestingPositions_updateThresholds()
		{
			for(int i = 0; i<this.chosenPVOPositions.Length; i++)
			{
				((PVOPositions)this.chosenPVOPositions[i]).OversoldThreshold =
					this.oversoldThreshold;
				((PVOPositions)this.chosenPVOPositions[i]).OverboughtThreshold =
					this.overboughtThreshold;
			}
		}

    protected virtual void updateTestingPositions(DateTime currentDate)
    {
			EndOfDayHistory endOfDayHistory =
				this.benchmark.GetEndOfDayHistory(
				new EndOfDayDateTime(currentDate.AddDays(-this.inSampleDays),
				EndOfDaySpecificTime.MarketOpen),
				new EndOfDayDateTime(currentDate,
				EndOfDaySpecificTime.MarketClose));
			EligibleTickers eligibles = 
				this.eligiblesSelector.GetEligibleTickers(endOfDayHistory);
			try{
				this.updateReturnsManager(endOfDayHistory.FirstEndOfDayDateTime,
				                          endOfDayHistory.LastEndOfDayDateTime);
				if(this.inSampleChooser != null)
					this.chosenPVOPositions = (TestingPositions[])inSampleChooser.AnalyzeInSample(eligibles, this.returnsManager);
				this.updateTestingPositions_updateThresholds();
				this.logOptimizationInfo(eligibles);
			}
			catch(TickerNotExchangedException ex)
			{	ex = ex;}
    }

		private bool optimalTestingPositionsAreToBeUpdated()
		{
			bool areToBeUpdated = false;
			if(this.inSampleChooser != null)
			{
				DateTime dateTimeForNextOptimization =
					this.lastOptimizationDateTime.AddDays(
					this.numDaysBetweenEachOptimization );
				areToBeUpdated =
					( ( ( this.account.Portfolio.Count == 0 )
					&& ( ( this.lastOptimizationDateTime == DateTime.MinValue ) ) ) ||
					( this.now().DateTime >= dateTimeForNextOptimization ) );
			}
			return areToBeUpdated;
		}

    /// <summary>
    /// Handles a "One hour after market close" event.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="eventArgs"></param>
    public virtual void OneHourAfterMarketCloseEventHandler(
      Object sender , EndOfDayTimingEventArgs endOfDayTimingEventArgs )
    {
      this.lastCloseDate = endOfDayTimingEventArgs.EndOfDayDateTime.DateTime;
      this.numDaysElapsedSinceLastOptimization++;
//OLD - numDaysBetweenEachOptimization --> market days      
//			if( this.account.Transactions.Count <= 1 || 
//				  (this.numDaysElapsedSinceLastOptimization == 
//            this.numDaysBetweenEachOptimization) )
				//num days without optimization has elapsed or
				//no transaction, except for adding cash, has been executed	
//NEW - numDaysBetweenEachOptimization --> calendar days 
			if ( this.optimalTestingPositionsAreToBeUpdated() )
      {
        this.updateTestingPositions(endOfDayTimingEventArgs.EndOfDayDateTime.DateTime);
        //sets tickers to be chosen next Market Close event
        this.numDaysElapsedSinceLastOptimization = 0;
				this.lastOptimizationDateTime = this.now().DateTime;
      }
    }
		#endregion
  }
}

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

[Quantproject-developers] QuantProject/b7_Scripts/TechnicalAnalysisTesting/Oscillators/FixedLevelOscillators/PortfolioValueOscillator PVO_CTOLogItem.cs, NONE, 1.1 PVO_CTOMain.cs, NONE, 1.1 PVO_CTOStrategy.cs, NONE, 1.1