[Quantproject-developers] QuantProject/b7_Scripts/TickerSelectionTesting GenomeManagerForEfficient

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

Update of /cvsroot/quantproject/QuantProject/b7_Scripts/TickerSelectionTesting
In directory sc8-pr-cvs16.sourceforge.net:/tmp/cvs-serv16773

Modified Files:
	GenomeManagerForEfficientCTCPortfolio.cs 
	GenomeManagerForEfficientCTOPortfolio.cs 
	GenomeManagerForEfficientOTCCTOPortfolio.cs 
	GenomeManagerForEfficientOTCPortfolio.cs 
	GenomeManagerForWeightedEfficientPortfolio.cs 
Log Message:
The new revision moves toward an intraday enabled framework.

EndOfDayDate time has been removed, DateTime is used now. The code has been changed accordingly.

Index: GenomeManagerForEfficientCTCPortfolio.cs
===================================================================
RCS file: /cvsroot/quantproject/QuantProject/b7_Scripts/TickerSelectionTesting/GenomeManagerForEfficientCTCPortfolio.cs,v
retrieving revision 1.14
retrieving revision 1.15
diff -C2 -d -r1.14 -r1.15
*** GenomeManagerForEfficientCTCPortfolio.cs	14 Jan 2008 23:38:36 -0000	1.14
--- GenomeManagerForEfficientCTCPortfolio.cs	29 Sep 2008 21:18:30 -0000	1.15
***************
*** 3,7 ****

  GenomeManagerForEfficientCTCPortfolio.cs
! Copyright (C) 2003 
  Marco Milletti

--- 3,7 ----

  GenomeManagerForEfficientCTCPortfolio.cs
! Copyright (C) 2003
  Marco Milletti

***************
*** 19,23 ****
  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;
--- 19,23 ----
  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;
***************
*** 34,90 ****
  {
  	/// <summary>
! 	/// Class to find efficient 
  	/// portfolios based on tickers' CloseToClose rates (adjusted values),
  	/// using the GeneticOptimizer
  	/// </summary>
  	[Serializable]
!   public class GenomeManagerForEfficientCTCPortfolio : GenomeManagerForEfficientPortfolio
!   {
!     private int numDaysForReturnCalculation;
!     private ReturnsManager returnsManager;
!     
!   	public GenomeManagerForEfficientCTCPortfolio(DataTable setOfInitialTickers,
!                                                  DateTime firstQuoteDate,
!                                                  DateTime lastQuoteDate,
!                                                  int numberOfTickersInPortfolio,
!                                                  int numDaysForReturnCalculation,
!                                                  double targetPerformance,
!                                                  PortfolioType portfolioType,
!                                                  string benchmark)
!                                                  :
!                                                 base(setOfInitialTickers,
!                                                 firstQuoteDate,
!                                                 lastQuoteDate,
!                                                 numberOfTickersInPortfolio,
!                                                 targetPerformance,
!                                                 portfolioType,
!                                                	benchmark)
!                                 
!                           
!     {
!     	this.numDaysForReturnCalculation = numDaysForReturnCalculation;
!     	this.setReturnsManager(firstQuoteDate, lastQuoteDate);
!     }
!   	
!     private void setReturnsManager(DateTime firstQuoteDate,
!                                    DateTime lastQuoteDate)
!     {
!     	EndOfDayDateTime firstEndOfDayDateTime =
! 				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			EndOfDayDateTime lastEndOfDayDateTime =
! 				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
!     	this.returnsManager = 
!     		new ReturnsManager( new CloseToCloseIntervals(
! 															  firstEndOfDayDateTime, 
! 																lastEndOfDayDateTime, 
! 																this.benchmark,
! 															  this.numDaysForReturnCalculation),
! 														new HistoricalAdjustedQuoteProvider() );
!     }
!     
!   	protected override float[] getStrategyReturns()
  		{
!   		return this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
  		}
!   }
  }
--- 34,92 ----
  {
  	/// <summary>
! 	/// Class to find efficient
  	/// portfolios based on tickers' CloseToClose rates (adjusted values),
  	/// using the GeneticOptimizer
  	/// </summary>
  	[Serializable]
! 	public class GenomeManagerForEfficientCTCPortfolio : GenomeManagerForEfficientPortfolio
! 	{
! 		private int numDaysForReturnCalculation;
! 		private ReturnsManager returnsManager;
! 		
! 		public GenomeManagerForEfficientCTCPortfolio(DataTable setOfInitialTickers,
! 		                                             DateTime firstQuoteDate,
! 		                                             DateTime lastQuoteDate,
! 		                                             int numberOfTickersInPortfolio,
! 		                                             int numDaysForReturnCalculation,
! 		                                             double targetPerformance,
! 		                                             PortfolioType portfolioType,
! 		                                             string benchmark)
! 			:
! 			base(setOfInitialTickers,
! 			     firstQuoteDate,
! 			     lastQuoteDate,
! 			     numberOfTickersInPortfolio,
! 			     targetPerformance,
! 			     portfolioType,
! 			     benchmark)
! 			
! 			
  		{
! 			this.numDaysForReturnCalculation = numDaysForReturnCalculation;
! 			this.setReturnsManager(firstQuoteDate, lastQuoteDate);
  		}
! 		
! 		private void setReturnsManager(DateTime firstQuoteDate,
! 		                               DateTime lastQuoteDate)
! 		{
! 			DateTime firstDateTime =
! 				HistoricalEndOfDayTimer.GetMarketOpen( firstQuoteDate );
! //				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			DateTime lastDateTime =
! 				HistoricalEndOfDayTimer.GetMarketClose( lastQuoteDate );
! //				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
! 			this.returnsManager =
! 				new ReturnsManager( new CloseToCloseIntervals(
! 					firstDateTime,
! 					lastDateTime,
! 					this.benchmark,
! 					this.numDaysForReturnCalculation),
! 				                   new HistoricalAdjustedQuoteProvider() );
! 		}
! 		
! 		protected override float[] getStrategyReturns()
! 		{
! 			return this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
! 		}
! 	}
  }

Index: GenomeManagerForEfficientOTCPortfolio.cs
===================================================================
RCS file: /cvsroot/quantproject/QuantProject/b7_Scripts/TickerSelectionTesting/GenomeManagerForEfficientOTCPortfolio.cs,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** GenomeManagerForEfficientOTCPortfolio.cs	14 Jan 2008 23:38:36 -0000	1.3
--- GenomeManagerForEfficientOTCPortfolio.cs	29 Sep 2008 21:18:30 -0000	1.4
***************
*** 3,7 ****

  GenomeManagerForEfficientOTCPortfolio.cs
! Copyright (C) 2003 
  Marco Milletti

--- 3,7 ----

  GenomeManagerForEfficientOTCPortfolio.cs
! Copyright (C) 2003
  Marco Milletti

***************
*** 19,23 ****
  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;
--- 19,23 ----
  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;
***************
*** 33,84 ****
  {
  	/// <summary>
! 	/// This class implements IGenomeManager, in order to find efficient 
  	/// portfolios based on tickers' OpenToClose rates, using the
  	/// GeneticOptimizer
  	/// </summary>
  	[Serializable]
!   public class GenomeManagerForEfficientOTCPortfolio : GenomeManagerForEfficientPortfolio
!   {
!     private ReturnsManager returnsManager;
!   	public GenomeManagerForEfficientOTCPortfolio(DataTable setOfInitialTickers,
!                                                  DateTime firstQuoteDate,
!                                                  DateTime lastQuoteDate,
!                                                  int numberOfTickersInPortfolio,
!                                                  double targetPerformance,
!                                                  PortfolioType portfolioType,
! 																								 string benchmark)
! 																									:base(setOfInitialTickers,
! 																											firstQuoteDate,
! 																											lastQuoteDate,
! 																											numberOfTickersInPortfolio,
! 																											targetPerformance,
! 																											portfolioType,
! 																											benchmark)
!                           
!     {
!     	this.setReturnsManager(firstQuoteDate, lastQuoteDate);
!     }
!     
!     private void setReturnsManager(DateTime firstQuoteDate,
!                                    DateTime lastQuoteDate)
!     {
!     	EndOfDayDateTime firstEndOfDayDateTime =
! 				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			EndOfDayDateTime lastEndOfDayDateTime =
! 				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
!     	this.returnsManager = 
!     		new ReturnsManager(
!             new DailyOpenToCloseIntervals(
! 										firstEndOfDayDateTime, 
! 										lastEndOfDayDateTime, 
! 										this.benchmark ),
!     			  new HistoricalRawQuoteProvider() );
!     }
!     
  		protected override float[] getStrategyReturns()
  		{
! 			return 
  				this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
  		}
!   }
  }
--- 33,86 ----
  {
  	/// <summary>
! 	/// This class implements IGenomeManager, in order to find efficient
  	/// portfolios based on tickers' OpenToClose rates, using the
  	/// GeneticOptimizer
  	/// </summary>
  	[Serializable]
! 	public class GenomeManagerForEfficientOTCPortfolio : GenomeManagerForEfficientPortfolio
! 	{
! 		private ReturnsManager returnsManager;
! 		public GenomeManagerForEfficientOTCPortfolio(DataTable setOfInitialTickers,
! 		                                             DateTime firstQuoteDate,
! 		                                             DateTime lastQuoteDate,
! 		                                             int numberOfTickersInPortfolio,
! 		                                             double targetPerformance,
! 		                                             PortfolioType portfolioType,
! 		                                             string benchmark)
! 			:base(setOfInitialTickers,
! 			      firstQuoteDate,
! 			      lastQuoteDate,
! 			      numberOfTickersInPortfolio,
! 			      targetPerformance,
! 			      portfolioType,
! 			      benchmark)
! 			
! 		{
! 			this.setReturnsManager(firstQuoteDate, lastQuoteDate);
! 		}
! 		
! 		private void setReturnsManager(DateTime firstQuoteDate,
! 		                               DateTime lastQuoteDate)
! 		{
! 			DateTime firstDateTime =
! 				HistoricalEndOfDayTimer.GetMarketOpen( firstQuoteDate );
! //				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			DateTime lastDateTime =
! 				HistoricalEndOfDayTimer.GetMarketClose( lastQuoteDate );
! //				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
! 			this.returnsManager =
! 				new ReturnsManager(
! 					new DailyOpenToCloseIntervals(
! 						firstDateTime,
! 						lastDateTime,
! 						this.benchmark ),
! 					new HistoricalRawQuoteProvider() );
! 		}
! 		
  		protected override float[] getStrategyReturns()
  		{
! 			return
  				this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
  		}
! 	}
  }

Index: GenomeManagerForEfficientCTOPortfolio.cs
===================================================================
RCS file: /cvsroot/quantproject/QuantProject/b7_Scripts/TickerSelectionTesting/GenomeManagerForEfficientCTOPortfolio.cs,v
retrieving revision 1.20
retrieving revision 1.21
diff -C2 -d -r1.20 -r1.21
*** GenomeManagerForEfficientCTOPortfolio.cs	14 Jan 2008 23:38:36 -0000	1.20
--- GenomeManagerForEfficientCTOPortfolio.cs	29 Sep 2008 21:18:30 -0000	1.21
***************
*** 3,7 ****

  GenomeManagerForEfficientCTOPortfolio.cs
! Copyright (C) 2003 
  Marco Milletti

--- 3,7 ----

  GenomeManagerForEfficientCTOPortfolio.cs
! Copyright (C) 2003
  Marco Milletti

***************
*** 19,23 ****
  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;
--- 19,23 ----
  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;
***************
*** 34,85 ****
  {
  	/// <summary>
! 	/// This class implements IGenomeManager, in order to find efficient 
  	/// portfolios based on tickers' CloseToOpen rates, using the
  	/// GeneticOptimizer
  	/// </summary>
  	[Serializable]
!   public class GenomeManagerForEfficientCTOPortfolio : GenomeManagerForEfficientPortfolio
!   {
!     private ReturnsManager returnsManager;
!   	
!   	public GenomeManagerForEfficientCTOPortfolio(DataTable setOfInitialTickers,
!                                                  DateTime firstQuoteDate,
!                                                  DateTime lastQuoteDate,
!                                                  int numberOfTickersInPortfolio,
!                                                  double targetPerformance,
!                                                  PortfolioType portfolioType,
! 																								 string benchmark)
!                                 :base(setOfInitialTickers,
!                                      firstQuoteDate,
!                                      lastQuoteDate,
!                                      numberOfTickersInPortfolio,
!                                      targetPerformance,
!                                      portfolioType,
!                                      benchmark)
!                           
!     {
!     	this.setReturnsManager(firstQuoteDate, lastQuoteDate); 
!     }
!   	
!      private void setReturnsManager(DateTime firstQuoteDate,
!                                    DateTime lastQuoteDate)
!     {
!     	EndOfDayDateTime firstEndOfDayDateTime =
! 				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			EndOfDayDateTime lastEndOfDayDateTime =
! 				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
!     	this.returnsManager = 
!     		new ReturnsManager( new CloseToOpenIntervals(
! 															  firstEndOfDayDateTime, 
! 																lastEndOfDayDateTime, 
! 																this.benchmark),
! 														new HistoricalAdjustedQuoteProvider() );
!     }
!     
!   	protected override float[] getStrategyReturns()
  		{
!   		return this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
  		}
!   	
!   }
  }
--- 34,87 ----
  {
  	/// <summary>
! 	/// This class implements IGenomeManager, in order to find efficient
  	/// portfolios based on tickers' CloseToOpen rates, using the
  	/// GeneticOptimizer
  	/// </summary>
  	[Serializable]
! 	public class GenomeManagerForEfficientCTOPortfolio : GenomeManagerForEfficientPortfolio
! 	{
! 		private ReturnsManager returnsManager;
! 		
! 		public GenomeManagerForEfficientCTOPortfolio(DataTable setOfInitialTickers,
! 		                                             DateTime firstQuoteDate,
! 		                                             DateTime lastQuoteDate,
! 		                                             int numberOfTickersInPortfolio,
! 		                                             double targetPerformance,
! 		                                             PortfolioType portfolioType,
! 		                                             string benchmark)
! 			:base(setOfInitialTickers,
! 			      firstQuoteDate,
! 			      lastQuoteDate,
! 			      numberOfTickersInPortfolio,
! 			      targetPerformance,
! 			      portfolioType,
! 			      benchmark)
! 			
  		{
! 			this.setReturnsManager(firstQuoteDate, lastQuoteDate);
  		}
! 		
! 		private void setReturnsManager(DateTime firstQuoteDate,
! 		                               DateTime lastQuoteDate)
! 		{
! 			DateTime firstDateTime =
! 				HistoricalEndOfDayTimer.GetMarketOpen( firstQuoteDate );
! //				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			DateTime lastDateTime =
! 				HistoricalEndOfDayTimer.GetMarketClose( lastQuoteDate );
! //				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
! 			this.returnsManager =
! 				new ReturnsManager( new CloseToOpenIntervals(
! 					firstDateTime,
! 					lastDateTime,
! 					this.benchmark),
! 				                   new HistoricalAdjustedQuoteProvider() );
! 		}
! 		
! 		protected override float[] getStrategyReturns()
! 		{
! 			return this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
! 		}
! 		
! 	}
  }

Index: GenomeManagerForEfficientOTCCTOPortfolio.cs
===================================================================
RCS file: /cvsroot/quantproject/QuantProject/b7_Scripts/TickerSelectionTesting/GenomeManagerForEfficientOTCCTOPortfolio.cs,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** GenomeManagerForEfficientOTCCTOPortfolio.cs	14 Jan 2008 23:38:36 -0000	1.6
--- GenomeManagerForEfficientOTCCTOPortfolio.cs	29 Sep 2008 21:18:30 -0000	1.7
***************
*** 3,7 ****

  GenomeManagerForEfficientOTCCTOPortfolio.cs
! Copyright (C) 2003 
  Marco Milletti

--- 3,7 ----

  GenomeManagerForEfficientOTCCTOPortfolio.cs
! Copyright (C) 2003
  Marco Milletti

***************
*** 19,23 ****
  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;
--- 19,23 ----
  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;
***************
*** 34,102 ****
  {
  	/// <summary>
! 	/// This class implements IGenomeManager, in order to find efficient 
  	/// portfolios based on the OTC and CTO strategy, using the
  	/// GeneticOptimizer
  	/// </summary>
  	[Serializable]
!   public class GenomeManagerForEfficientOTCCTOPortfolio : GenomeManagerForEfficientPortfolio
!   {
!     private ReturnsManager returnsManager;
!   	
!     public GenomeManagerForEfficientOTCCTOPortfolio(DataTable setOfInitialTickers,
!                                                  DateTime firstQuoteDate,
!                                                  DateTime lastQuoteDate,
!                                                  int numberOfTickersInPortfolio,
!                                                  double targetPerformance,
!                                                  PortfolioType portfolioType,
!                                                  string benchmark)
!                                 :base(setOfInitialTickers,
!                                      firstQuoteDate,
!                                      lastQuoteDate,
!                                      numberOfTickersInPortfolio,
!                                      targetPerformance,
!                                      portfolioType,
!                                      benchmark)
!                           
!     {
!       this.setReturnsManager(firstQuoteDate, lastQuoteDate);
!     }
!     //if the genome manager derives from genome manager without weights,
  		//delete override key word
! 		protected ReturnIntervals getReturnIntervals(EndOfDayDateTime firstEndOfDayDateTime,
! 																													EndOfDayDateTime lastEndOfDayDateTime)
  		{
! 			return 
  				new OpenToCloseCloseToOpenIntervals(
! 				firstEndOfDayDateTime, 
! 				lastEndOfDayDateTime, 
! 				this.benchmark);
  		}

!   	private void setReturnsManager(DateTime firstQuoteDate,
!                                    DateTime lastQuoteDate)
!     {
!     	EndOfDayDateTime firstEndOfDayDateTime =
! 				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			EndOfDayDateTime lastEndOfDayDateTime =
! 				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
!     	this.returnsManager = 
!     		new ReturnsManager( this.getReturnIntervals(firstEndOfDayDateTime,
! 																 lastEndOfDayDateTime),
! 														new HistoricalAdjustedQuoteProvider() );
!     }
!   	
!   	protected override float[] getStrategyReturns()
  		{
!   		float[] returnValue;
!   		returnValue = this.weightedPositionsFromGenome.GetReturns(
!               this.returnsManager ) ;
! 	   	for(int i = 0; i<returnValue.Length; i++)
! 	  		if(i%2 != 0)
! 	  		//returnValue[i] is a CloseToOpen return:
! 	  		//the strategy implies to reverse positions at night
! 	  			returnValue[i] = - returnValue[i];
! 	  	
! 	  	return returnValue;
  		}
!   }
  }
--- 34,105 ----
  {
  	/// <summary>
! 	/// This class implements IGenomeManager, in order to find efficient
  	/// portfolios based on the OTC and CTO strategy, using the
  	/// GeneticOptimizer
  	/// </summary>
  	[Serializable]
! 	public class GenomeManagerForEfficientOTCCTOPortfolio : GenomeManagerForEfficientPortfolio
! 	{
! 		private ReturnsManager returnsManager;
! 		
! 		public GenomeManagerForEfficientOTCCTOPortfolio(DataTable setOfInitialTickers,
! 		                                                DateTime firstQuoteDate,
! 		                                                DateTime lastQuoteDate,
! 		                                                int numberOfTickersInPortfolio,
! 		                                                double targetPerformance,
! 		                                                PortfolioType portfolioType,
! 		                                                string benchmark)
! 			:base(setOfInitialTickers,
! 			      firstQuoteDate,
! 			      lastQuoteDate,
! 			      numberOfTickersInPortfolio,
! 			      targetPerformance,
! 			      portfolioType,
! 			      benchmark)
! 			
! 		{
! 			this.setReturnsManager(firstQuoteDate, lastQuoteDate);
! 		}
! 		//if the genome manager derives from genome manager without weights,
  		//delete override key word
! 		protected ReturnIntervals getReturnIntervals(
! 			DateTime firstDateTime,
! 			DateTime lastDateTime)
  		{
! 			return
  				new OpenToCloseCloseToOpenIntervals(
! 					firstDateTime,
! 					lastDateTime,
! 					this.benchmark);
  		}

! 		private void setReturnsManager(DateTime firstQuoteDate,
! 		                               DateTime lastQuoteDate)
  		{
! 			DateTime firstDateTime =
! 				HistoricalEndOfDayTimer.GetMarketOpen( firstQuoteDate );
! //				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			DateTime lastDateTime =
! 				HistoricalEndOfDayTimer.GetMarketClose( lastQuoteDate );
! //				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
! 			this.returnsManager =
! 				new ReturnsManager( this.getReturnIntervals(firstDateTime,
! 				                                            lastDateTime),
! 				                   new HistoricalAdjustedQuoteProvider() );
  		}
! 		
! 		protected override float[] getStrategyReturns()
! 		{
! 			float[] returnValue;
! 			returnValue = this.weightedPositionsFromGenome.GetReturns(
! 				this.returnsManager ) ;
! 			for(int i = 0; i<returnValue.Length; i++)
! 				if(i%2 != 0)
! 				//returnValue[i] is a CloseToOpen return:
! 				//the strategy implies to reverse positions at night
! 				returnValue[i] = - returnValue[i];
! 			
! 			return returnValue;
! 		}
! 	}
  }

Index: GenomeManagerForWeightedEfficientPortfolio.cs
===================================================================
RCS file: /cvsroot/quantproject/QuantProject/b7_Scripts/TickerSelectionTesting/GenomeManagerForWeightedEfficientPortfolio.cs,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** GenomeManagerForWeightedEfficientPortfolio.cs	14 Jan 2008 23:38:36 -0000	1.8
--- GenomeManagerForWeightedEfficientPortfolio.cs	29 Sep 2008 21:18:30 -0000	1.9
***************
*** 3,7 ****

  GenomeManagerForWeightedEfficientPortfolio.cs
! Copyright (C) 2003 
  Marco Milletti

--- 3,7 ----

  GenomeManagerForWeightedEfficientPortfolio.cs
! Copyright (C) 2003
  Marco Milletti

***************
*** 19,23 ****
  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;
--- 19,23 ----
  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;
***************
*** 38,95 ****
  namespace QuantProject.Scripts.TickerSelectionTesting.EfficientPortfolios
  {
!   /// <summary>
!   /// This is the base class implementing IGenomeManager, in order to find
!   /// efficient portfolios in which tickers are weighted differently
!   /// </summary>
!   [Serializable]
!   public abstract class GenomeManagerForWeightedEfficientPortfolio : GenomeManagerForEfficientPortfolio
!   {
!     private ReturnsManager returnsManager;
!   	
!     public GenomeManagerForWeightedEfficientPortfolio(DataTable setOfInitialTickers,
!       DateTime firstQuoteDate,
!       DateTime lastQuoteDate,
!       int numberOfTickersInPortfolio,
!       double targetPerformance,
!       PortfolioType portfolioType,
!       string benchmark):base(setOfInitialTickers,
!                                         firstQuoteDate,
!                                         lastQuoteDate,
!                                         numberOfTickersInPortfolio,
!                                         targetPerformance,
!                                         portfolioType, benchmark)
!                           
!     {
!       this.genomeSize = 2*this.genomeSize;
!       //at even position the gene is used for finding
!       //the coefficient for the ticker represented at the next odd position
!       this.setReturnsManager(firstQuoteDate, lastQuoteDate);
! 	  }
!  		
! 		protected abstract ReturnIntervals getReturnIntervals(EndOfDayDateTime firstEndOfDayDateTime,
! 																												  EndOfDayDateTime lastEndOfDayDateTime);

!     private void setReturnsManager(DateTime firstQuoteDate,
!                                    DateTime lastQuoteDate)
!     {
!     	EndOfDayDateTime firstEndOfDayDateTime =
! 				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			EndOfDayDateTime lastEndOfDayDateTime =
! 				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
!     	this.returnsManager = 
!     		new ReturnsManager( this.getReturnIntervals(firstEndOfDayDateTime,
! 																 lastEndOfDayDateTime) ,
! 														new HistoricalAdjustedQuoteProvider() );
!     }
!     
!   	//this is a very generic implementation that will
!  		//be overriden by inherited classes specifying 
!  		//the strategy and the type of returns
!   	protected override float[] getStrategyReturns()
  		{
  			return this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
  		}
!   	
!     #region override Decode

  		protected override double getTickerWeight(int[] genes, int tickerPositionInGenes)
--- 38,98 ----
  namespace QuantProject.Scripts.TickerSelectionTesting.EfficientPortfolios
  {
! 	/// <summary>
! 	/// This is the base class implementing IGenomeManager, in order to find
! 	/// efficient portfolios in which tickers are weighted differently
! 	/// </summary>
! 	[Serializable]
! 	public abstract class GenomeManagerForWeightedEfficientPortfolio : GenomeManagerForEfficientPortfolio
! 	{
! 		private ReturnsManager returnsManager;
! 		
! 		public GenomeManagerForWeightedEfficientPortfolio(DataTable setOfInitialTickers,
! 		                                                  DateTime firstQuoteDate,
! 		                                                  DateTime lastQuoteDate,
! 		                                                  int numberOfTickersInPortfolio,
! 		                                                  double targetPerformance,
! 		                                                  PortfolioType portfolioType,
! 		                                                  string benchmark):base(setOfInitialTickers,
! 		                       firstQuoteDate,
! 		                       lastQuoteDate,
! 		                       numberOfTickersInPortfolio,
! 		                       targetPerformance,
! 		                       portfolioType, benchmark)
! 			
! 		{
! 			this.genomeSize = 2*this.genomeSize;
! 			//at even position the gene is used for finding
! 			//the coefficient for the ticker represented at the next odd position
! 			this.setReturnsManager(firstQuoteDate, lastQuoteDate);
! 		}
! 		
! 		protected abstract ReturnIntervals getReturnIntervals(
! 			DateTime firstDateTime,
! 			DateTime lastDateTime);

! 		private void setReturnsManager(DateTime firstQuoteDate,
! 		                               DateTime lastQuoteDate)
! 		{
! 			DateTime firstDateTime =
! 				HistoricalEndOfDayTimer.GetMarketOpen( firstQuoteDate );
! //				new EndOfDayDateTime(firstQuoteDate, EndOfDaySpecificTime.MarketOpen);
! 			DateTime lastDateTime =
! 				HistoricalEndOfDayTimer.GetMarketClose( lastQuoteDate );
! //				new EndOfDayDateTime(lastQuoteDate, EndOfDaySpecificTime.MarketClose);
! 			this.returnsManager =
! 				new ReturnsManager( this.getReturnIntervals(firstDateTime,
! 				                                            lastDateTime) ,
! 				                   new HistoricalAdjustedQuoteProvider() );
! 		}
! 		
! 		//this is a very generic implementation that will
! 		//be overriden by inherited classes specifying
! 		//the strategy and the type of returns
! 		protected override float[] getStrategyReturns()
  		{
  			return this.weightedPositionsFromGenome.GetReturns(this.returnsManager);
  		}
! 		
! 		#region override Decode

  		protected override double getTickerWeight(int[] genes, int tickerPositionInGenes)
***************
*** 109,253 ****
  		}

!     public override object Decode(Genome genome)
!     {
!       string[] arrayOfTickers = new string[genome.Genes().Length/2];
!       double[] arrayOfTickersWeights = new double[genome.Genes().Length/2];
!       int indexOfTicker;
!       int i = 0;//for the arrayOfTickers
!       for(int index = 0; index < genome.Genes().Length; index++)
!       {
!         if(index%2==1)
!           //indexForTicker is contained in genes at odd position
!         {
!           indexOfTicker = (int)genome.Genes().GetValue(index);
!           arrayOfTickers[i] = this.decode_getTickerCodeForLongOrShortTrade(indexOfTicker);
!           arrayOfTickersWeights[i] = this.getTickerWeight(genome.Genes(), index);
!           i++;
!         }
!       }
!       GenomeMeaning meaning = new GenomeMeaning(arrayOfTickers,
!                                                 arrayOfTickersWeights);
!       return meaning;
!     }
!     #endregion

!     public override int GetNewGeneValue(Genome genome, int genePosition)
!     {
!       // in this implementation only new gene values pointing to tickers
!       // must be different from the others already stored (in odd positions of genome)
!       int returnValue = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePosition),
!                                                               genome.GetMaxValueForGenes(genePosition) + 1);
!       while(genePosition%2 == 1 
!             && GenomeManipulator.IsTickerContainedInGenome(returnValue,genome))
!       //while in the given position has to be stored
!       //a new gene pointing to a ticker and
!       //the proposed returnValue points to a ticker
!       //already stored in the given genome
!       {
!         // a new returnValue has to be generated
!       	returnValue = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePosition),
!                                                             genome.GetMaxValueForGenes(genePosition) + 1);
!       }
!       return returnValue;
!     }
!     
!     #region override Mutate
!     
!     //OLD VERSION   
! //    public override void Mutate(Genome genome, double mutationRate)
! //    {
! //      // in this implementation only one gene is mutated
! //      int genePositionToBeMutated = GenomeManagement.RandomGenerator.Next(genome.Size);
! //      int newValueForGene = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
! //                                                                  genome.GetMaxValueForGenes(genePositionToBeMutated) +1);
! //       
! //      while(genePositionToBeMutated%2 == 1 &&
! //            GenomeManipulator.IsTickerContainedInGenome(newValueForGene,genome))
! //      //while in the proposed genePositionToBeMutated has to be stored
! //      //a new gene pointing to a ticker and
! //      //the proposed newValueForGene points to a ticker
! //      //already stored in the given genome
! //      {
! //        newValueForGene = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
! //                                                                genome.GetMaxValueForGenes(genePositionToBeMutated) +1);
! //      }
! //      GenomeManagement.MutateOneGene(genome, mutationRate,
! //        genePositionToBeMutated, newValueForGene);
! //    }

!     private int mutate_MutateOnlyOneWeight_getNewWeight(Genome genome, int genePositionToBeMutated)
!     {
!       int returnValue;
!       double partOfGeneToSubtractOrAdd = 0.03;
!       int geneValue = genome.GetGeneValue(genePositionToBeMutated);
!       int subtractOrAdd = GenomeManagement.RandomGenerator.Next(2);
!       if(subtractOrAdd == 1)//subtract a part of the gene value from the gene value itself
!       {
!       	if( geneValue < 0 )
!       		returnValue = Math.Max( geneValue - Convert.ToInt32(partOfGeneToSubtractOrAdd*Math.Abs(geneValue)),
!       		                        genome.GetMinValueForGenes(genePositionToBeMutated) );
!       	else // geneValue >= 0
!       		returnValue = geneValue - Convert.ToInt32(partOfGeneToSubtractOrAdd*Math.Abs(geneValue));
!       }
!       else//add a part of the gene value to the gene value itself
!       {
!       	if( geneValue < 0 )
!       		returnValue = geneValue + Convert.ToInt32(partOfGeneToSubtractOrAdd*Math.Abs(geneValue));
!       	else // geneValue >= 0
!       		returnValue = Math.Min(genome.GetMaxValueForGenes(genePositionToBeMutated),
!                                	 geneValue + Convert.ToInt32(partOfGeneToSubtractOrAdd*geneValue));
!       }
!       return returnValue;
!     }

!     private void mutate_MutateOnlyOneWeight(Genome genome)
!     {
!       int genePositionToBeMutated = GenomeManagement.RandomGenerator.Next(genome.Size);
!       while(genePositionToBeMutated%2 == 1 )
!         //while the proposed genePositionToBeMutated points to a ticker
!         genePositionToBeMutated = GenomeManagement.RandomGenerator.Next(genome.Size);
! 	      
!       int newValueForGene = this.mutate_MutateOnlyOneWeight_getNewWeight(genome, genePositionToBeMutated);	
! 	    
!       GenomeManagement.MutateOneGene(genome, genePositionToBeMutated, newValueForGene);
!     }
!     
!     private void mutate_MutateAllGenes(Genome genome)
!     {
!       for(int genePositionToBeMutated = 0;
!           genePositionToBeMutated < genome.Genes().Length;
!           genePositionToBeMutated ++)
!       {
!         int newValueForGene = 
!           GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
!             genome.GetMaxValueForGenes(genePositionToBeMutated) + 1);
!         while(genePositionToBeMutated%2 == 1 
!           && GenomeManipulator.IsTickerContainedInGenome(newValueForGene,genome))
!           //while in the given position has to be stored
!           //a new gene pointing to a ticker and
!           //the proposed newValueForGene points to a ticker
!           //already stored in the given genome
!           // a new newalueForGene has to be generated
!           newValueForGene = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
!             										genome.GetMaxValueForGenes(genePositionToBeMutated) + 1);
! 		      
!         genome.SetGeneValue(newValueForGene, genePositionToBeMutated);
!       }
!     }
!         
!     //new version
  		//mutation means just a change in one single weight
  		//or in a complete new genome (with a probability of 50%)
!     public override void Mutate(Genome genome)
!     {
!     	int mutateOnlyOneWeight = GenomeManagement.RandomGenerator.Next(2);
!     	if(mutateOnlyOneWeight == 1)
!     	 	this.mutate_MutateOnlyOneWeight(genome);
!     	else//mutate all genome's genes
!     	  this.mutate_MutateAllGenes(genome); 
!     }

!     #endregion

!   }
  }
--- 112,256 ----
  		}

! 		public override object Decode(Genome genome)
! 		{
! 			string[] arrayOfTickers = new string[genome.Genes().Length/2];
! 			double[] arrayOfTickersWeights = new double[genome.Genes().Length/2];
! 			int indexOfTicker;
! 			int i = 0;//for the arrayOfTickers
! 			for(int index = 0; index < genome.Genes().Length; index++)
! 			{
! 				if(index%2==1)
! 					//indexForTicker is contained in genes at odd position
! 				{
! 					indexOfTicker = (int)genome.Genes().GetValue(index);
! 					arrayOfTickers[i] = this.decode_getTickerCodeForLongOrShortTrade(indexOfTicker);
! 					arrayOfTickersWeights[i] = this.getTickerWeight(genome.Genes(), index);
! 					i++;
! 				}
! 			}
! 			GenomeMeaning meaning = new GenomeMeaning(arrayOfTickers,
! 			                                          arrayOfTickersWeights);
! 			return meaning;
! 		}
! 		#endregion

! 		public override int GetNewGeneValue(Genome genome, int genePosition)
! 		{
! 			// in this implementation only new gene values pointing to tickers
! 			// must be different from the others already stored (in odd positions of genome)
! 			int returnValue = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePosition),
! 			                                                        genome.GetMaxValueForGenes(genePosition) + 1);
! 			while(genePosition%2 == 1
! 			      && GenomeManipulator.IsTickerContainedInGenome(returnValue,genome))
! 				//while in the given position has to be stored
! 				//a new gene pointing to a ticker and
! 				//the proposed returnValue points to a ticker
! 				//already stored in the given genome
! 			{
! 				// a new returnValue has to be generated
! 				returnValue = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePosition),
! 				                                                    genome.GetMaxValueForGenes(genePosition) + 1);
! 			}
! 			return returnValue;
! 		}

! 		#region override Mutate
! 		
! 		//OLD VERSION
! 		//    public override void Mutate(Genome genome, double mutationRate)
! 		//    {
! 		//      // in this implementation only one gene is mutated
! 		//      int genePositionToBeMutated = GenomeManagement.RandomGenerator.Next(genome.Size);
! 		//      int newValueForGene = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
! 		//                                                                  genome.GetMaxValueForGenes(genePositionToBeMutated) +1);
! //
! 		//      while(genePositionToBeMutated%2 == 1 &&
! 		//            GenomeManipulator.IsTickerContainedInGenome(newValueForGene,genome))
! 		//      //while in the proposed genePositionToBeMutated has to be stored
! 		//      //a new gene pointing to a ticker and
! 		//      //the proposed newValueForGene points to a ticker
! 		//      //already stored in the given genome
! 		//      {
! 		//        newValueForGene = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
! 		//                                                                genome.GetMaxValueForGenes(genePositionToBeMutated) +1);
! 		//      }
! 		//      GenomeManagement.MutateOneGene(genome, mutationRate,
! 		//        genePositionToBeMutated, newValueForGene);
! 		//    }
! 		
! 		private int mutate_MutateOnlyOneWeight_getNewWeight(Genome genome, int genePositionToBeMutated)
! 		{
! 			int returnValue;
! 			double partOfGeneToSubtractOrAdd = 0.03;
! 			int geneValue = genome.GetGeneValue(genePositionToBeMutated);
! 			int subtractOrAdd = GenomeManagement.RandomGenerator.Next(2);
! 			if(subtractOrAdd == 1)//subtract a part of the gene value from the gene value itself
! 			{
! 				if( geneValue < 0 )
! 					returnValue = Math.Max( geneValue - Convert.ToInt32(partOfGeneToSubtractOrAdd*Math.Abs(geneValue)),
! 					                       genome.GetMinValueForGenes(genePositionToBeMutated) );
! 				else // geneValue >= 0
! 					returnValue = geneValue - Convert.ToInt32(partOfGeneToSubtractOrAdd*Math.Abs(geneValue));
! 			}
! 			else//add a part of the gene value to the gene value itself
! 			{
! 				if( geneValue < 0 )
! 					returnValue = geneValue + Convert.ToInt32(partOfGeneToSubtractOrAdd*Math.Abs(geneValue));
! 				else // geneValue >= 0
! 					returnValue = Math.Min(genome.GetMaxValueForGenes(genePositionToBeMutated),
! 					                       geneValue + Convert.ToInt32(partOfGeneToSubtractOrAdd*geneValue));
! 			}
! 			return returnValue;
! 		}

! 		private void mutate_MutateOnlyOneWeight(Genome genome)
! 		{
! 			int genePositionToBeMutated = GenomeManagement.RandomGenerator.Next(genome.Size);
! 			while(genePositionToBeMutated%2 == 1 )
! 				//while the proposed genePositionToBeMutated points to a ticker
! 				genePositionToBeMutated = GenomeManagement.RandomGenerator.Next(genome.Size);
! 			
! 			int newValueForGene = this.mutate_MutateOnlyOneWeight_getNewWeight(genome, genePositionToBeMutated);
! 			
! 			GenomeManagement.MutateOneGene(genome, genePositionToBeMutated, newValueForGene);
! 		}
! 		
! 		private void mutate_MutateAllGenes(Genome genome)
! 		{
! 			for(int genePositionToBeMutated = 0;
! 			    genePositionToBeMutated < genome.Genes().Length;
! 			    genePositionToBeMutated ++)
! 			{
! 				int newValueForGene =
! 					GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
! 					                                      genome.GetMaxValueForGenes(genePositionToBeMutated) + 1);
! 				while(genePositionToBeMutated%2 == 1
! 				      && GenomeManipulator.IsTickerContainedInGenome(newValueForGene,genome))
! 					//while in the given position has to be stored
! 					//a new gene pointing to a ticker and
! 					//the proposed newValueForGene points to a ticker
! 					//already stored in the given genome
! 					// a new newalueForGene has to be generated
! 					newValueForGene = GenomeManagement.RandomGenerator.Next(genome.GetMinValueForGenes(genePositionToBeMutated),
! 					                                                        genome.GetMaxValueForGenes(genePositionToBeMutated) + 1);
! 				
! 				genome.SetGeneValue(newValueForGene, genePositionToBeMutated);
! 			}
! 		}
! 		
! 		//new version
  		//mutation means just a change in one single weight
  		//or in a complete new genome (with a probability of 50%)
! 		public override void Mutate(Genome genome)
! 		{
! 			int mutateOnlyOneWeight = GenomeManagement.RandomGenerator.Next(2);
! 			if(mutateOnlyOneWeight == 1)
! 				this.mutate_MutateOnlyOneWeight(genome);
! 			else//mutate all genome's genes
! 				this.mutate_MutateAllGenes(genome);
! 		}

! 		#endregion

! 	}
  }