You are viewing an archived page from the original site. Go to the new numericalmethod.com →

Changeset 1495 in algoquant


Ignore:
Timestamp:
12/30/2013 4:48:13 PM (9 days ago)
Author:
haksunli
Message:

CHG: renamed '*Equity*' to '*Stock*'

Files:
1 deleted
132 edited
8 moved

Legend:

Unmodified
Added
Removed

  • core/src/main/java/com/numericalmethod/algoquant/data/cache/processor/transformer/DoubleDataTransformers.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.type.Depth; 
    26 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     26import com.numericalmethod.algoquant.data.type.StockEOD; 
    2727import com.numericalmethod.algoquant.data.type.Price; 
    2828 
    … …  
    3737    } 
    3838    /** 
    39      * This converts an {@link EquityEOD} data to a {@code Double}. 
     39     * This converts an {@link StockEOD} data to a {@code Double}. 
    4040     */ 
    41     public static final DoubleDataTransformer<EquityEOD> EQUITYEOD = 
    42         new DoubleDataTransformer<EquityEOD>() { 
     41    public static final DoubleDataTransformer<StockEOD> STOCK_EOD = 
     42        new DoubleDataTransformer<StockEOD>() { 
    4343            @Override 
    44             public Double transform(EquityEOD data) { 
     44            public Double transform(StockEOD data) { 
    4545                return data.getAdjClose(); 
    4646            } 

  • core/src/main/java/com/numericalmethod/algoquant/data/cache/processor/transformer/DoubleEntryTransformers.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.type.Depth; 
    26 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     26import com.numericalmethod.algoquant.data.type.StockEOD; 
    2727import com.numericalmethod.algoquant.data.type.Price; 
    2828 
    … …  
    3737    } 
    3838    /** 
    39      * This converts an {@link EquityEOD} data to a {@code Double}. 
     39     * This converts an {@link StockEOD} data to a {@code Double}. 
    4040     */ 
    41     public static final DoubleEntryTransformer<EquityEOD> EQUITYEOD = 
    42         new DoubleEntryTransformer<EquityEOD>(DoubleDataTransformers.EQUITYEOD); 
     41    public static final DoubleEntryTransformer<StockEOD> STOCK_EOD = 
     42        new DoubleEntryTransformer<StockEOD>(DoubleDataTransformers.STOCK_EOD); 
    4343    /** 
    4444     * This converts a {@link Price} data to a {@code Double}. 

  • core/src/main/java/com/numericalmethod/algoquant/data/calendar/holiday/ExchangeIndex.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.calendar.TimeZoneUtils; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828import java.util.Arrays; 
    … …  
    4242 
    4343    HKEX( 
    44     Arrays.asList(new Equity("^HSI", Exchange.HKEX)), 
     44    Arrays.asList(new Stock("^HSI", Exchange.HKEX)), 
    4545    new DateMidnight(1990, 1, 1, TimeZoneUtils.HONG_KONG)), 
    4646    NYSE( 
    … …  
    5151     * finding the union of trading dates would increase the error resilience. 
    5252     */ 
    53     new Equity("^IXIC", Exchange.NASDAQ), 
    54     new Equity("IBM", Exchange.NYSE)), 
     53    new Stock("^IXIC", Exchange.NASDAQ), 
     54    new Stock("IBM", Exchange.NYSE)), 
    5555    //        JodaTimeUtils.getDate(1962, 1, 1, TimeZoneUtils.NYSE)), // earliest available date (comment out for better performance while loading) 
    5656    new DateMidnight(1980, 1, 1, TimeZoneUtils.NEW_YORK)), 
    5757    SGX( 
    5858    Arrays.asList( 
    59     new Equity("^STI", Exchange.SGX), // STRAITS TIMES INDEX 
    60     new Equity("S68.SI", Exchange.SGX), // Singapore Exchange Ltd. 
    61     new Equity("FSTAS.SI", Exchange.SGX)), // FTSE ST All-Share Index 
     59    new Stock("^STI", Exchange.SGX), // STRAITS TIMES INDEX 
     60    new Stock("S68.SI", Exchange.SGX), // Singapore Exchange Ltd. 
     61    new Stock("FSTAS.SI", Exchange.SGX)), // FTSE ST All-Share Index 
    6262    new DateMidnight(1997, 1, 1, TimeZoneUtils.SINGAPORE)); 
    63     private final List<Equity> equities; 
     63    private final List<Stock> equities; 
    6464    private final DateMidnight earliestDate; 
    6565    private final DateTimeZone timeZone; 
    6666 
    67     private ExchangeIndex(List<Equity> equities, DateMidnight earliestDate) { 
     67    private ExchangeIndex(List<Stock> equities, DateMidnight earliestDate) { 
    6868        this.equities = equities; 
    6969        this.earliestDate = earliestDate; 
    … …  
    7171    } 
    7272 
    73     public List<Equity> getEquities() { 
     73    public List<Stock> getEquities() { 
    7474        return Collections.unmodifiableList(equities); 
    7575    } 

  • core/src/main/java/com/numericalmethod/algoquant/data/calendar/holiday/WebHolidayUpdater.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEODWebDownloader; 
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    28 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.data.type.StockEOD; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    31 import java.util.HashSet; 
    32 import java.util.List; 
    33 import java.util.Set; 
     31import java.util.*; 
    3432import org.joda.time.DateMidnight; 
    3533import org.joda.time.Period; 
    … …  
    4341public class WebHolidayUpdater { 
    4442 
    45     private final List<Equity> equities; 
     43    private final List<Stock> equities; 
    4644 
    47     public WebHolidayUpdater(List<Equity> equities) { 
     45    public WebHolidayUpdater(List<Stock> equities) { 
    4846        this.equities = equities; 
    4947    } 
    … …  
    5957        Set<DateMidnight> tradingDay = new HashSet<DateMidnight>(8192); 
    6058 
    61         for (Equity indicator : equities) { 
     59        for (Stock indicator : equities) { 
    6260 
    63             SequentialCache<EquityEOD> yahooCache = 
     61            SequentialCache<StockEOD> yahooCache = 
    6462                getYahooCache(fromDate, toDate, indicator); 
    6563 
    66             for (TimedEntry<EquityEOD> te : yahooCache) { 
     64            for (TimedEntry<StockEOD> te : yahooCache) { 
    6765                if (isTradingDay(te.getData())) { 
    6866                    tradingDay.add(te.getTime().toDateMidnight()); 
    … …  
    8381    } 
    8482 
    85     private SequentialCache<EquityEOD> getYahooCache(DateMidnight fromDate, DateMidnight endDate, 
    86         Equity yahooInstrument) { 
     83    private SequentialCache<StockEOD> getYahooCache(DateMidnight fromDate, DateMidnight endDate, 
     84                                                    Stock yahooInstrument) { 
    8785        YahooEODWebDownloader downloader = new YahooEODWebDownloader(yahooInstrument); 
    88         SequentialCache<EquityEOD> cache = downloader.getCache(fromDate.toDateTime(), endDate.toDateTime()); 
     86        SequentialCache<StockEOD> cache = downloader.getCache(fromDate.toDateTime(), endDate.toDateTime()); 
    8987        return cache; 
    9088    } 
    9189 
    92     private boolean isTradingDay(EquityEOD equityEOD) { 
     90    private boolean isTradingDay(StockEOD stockEOD) { 
    9391        /* 
    9492         * We assume if the volume of a particular day is zero and its open, 
    … …  
    9694         * dummy data row returned by !Yahoo finance. 
    9795         */ 
    98         return !(equityEOD.getVolume() == 0 
    99             && equityEOD.getClose() == equityEOD.getHigh() 
    100             && equityEOD.getHigh() == equityEOD.getLow() 
    101             && equityEOD.getLow() == equityEOD.getOpen()); 
     96        return !(stockEOD.getVolume() == 0 
     97                 && stockEOD.getClose() == stockEOD.getHigh() 
     98                 && stockEOD.getHigh() == stockEOD.getLow() 
     99                 && stockEOD.getLow() == stockEOD.getOpen()); 
    102100    } 
    103101} 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/CompanyHistory.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727 
    2828/** 
    … …  
    3434 
    3535    /** 
    36      * Gets the equity represented by this company. 
     36     * Gets the stock represented by this company. 
    3737     * 
    38      * @return the equity of this company 
     38     * @return the stock of this company 
    3939     */ 
    40     public Equity getEquity(); 
     40    public Stock getStock(); 
    4141 
    4242    public CompanyInfo getCompanyInfo(); 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/CompanyHistoryImpl.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.equity; 
    2424 
    25 import com.numericalmethod.algoquant.data.cache.BufferCache; 
    26 import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    27 import com.numericalmethod.algoquant.data.cache.SequentialCache; 
    28 import com.numericalmethod.algoquant.data.cache.VectorCache; 
     25import com.numericalmethod.algoquant.data.cache.*; 
    2926import com.numericalmethod.algoquant.data.cache.VectorCache.Vector; 
    3027import com.numericalmethod.algoquant.data.equity.measure.AccountingData; 
    3128import com.numericalmethod.algoquant.data.equity.measure.TradingData; 
    3229import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    33 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3431 
    3532/** 
    … …  
    3936public class CompanyHistoryImpl implements CompanyHistory { 
    4037 
    41     private final Equity equity; 
     38    private final Stock stock; 
    4239    private final CompanyInfo info; 
    4340    private final BufferCache<CompanyProfile> buffer = new BufferCache<CompanyProfile>(); 
    4441 
    4542    public CompanyHistoryImpl( 
    46         Equity equity, 
     43        Stock stock, 
    4744        CompanyInfo info, 
    4845        SequentialCache<? extends TradingData> trading, 
    4946        SequentialCache<? extends AccountingData> accounting) { 
    50         this.equity = equity; 
     47        this.stock = stock; 
    5148        this.info = info; 
    5249 
    … …  
    5754            TradingData tradingData = (TradingData) vector.get(1); 
    5855            AccountingData accountingData = (AccountingData) vector.get(2); 
    59             buffer.add(entry.getTime(), new CompanyProfileImpl(equity, tradingData, accountingData)); 
     56            buffer.add(entry.getTime(), new CompanyProfileImpl(stock, tradingData, accountingData)); 
    6057        } 
    6158    } 
    6259 
    6360    public CompanyHistoryImpl( 
    64         Equity equity, 
     61        Stock stock, 
    6562        CompanyInfo info, 
    6663        SequentialCache<? extends CompanyProfile> profiles) { 
    67         this.equity = equity; 
     64        this.stock = stock; 
    6865        this.info = info; 
    6966 
    … …  
    7471 
    7572    @Override 
    76     public Equity getEquity() { 
    77         return equity; 
     73    public Stock getStock() { 
     74        return stock; 
    7875    } 
    7976 
    … …  
    9087    @Override 
    9188    public String toString() { 
    92         return String.format("history of %s", equity); 
     89        return String.format("history of %s", stock); 
    9390    } 
    9491} 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/CompanyProfile.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727 
    2828/** 
    … …  
    3333public interface CompanyProfile { 
    3434 
    35     public Equity getEquity(); 
     35    public Stock getStock(); 
    3636 
    3737    public double getPrice(); 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/CompanyProfileImpl.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.equity; 
    2424 
    25 import com.numericalmethod.algoquant.data.equity.measure.AccountingData; 
    26 import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    27 import com.numericalmethod.algoquant.data.equity.measure.TradingData; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.data.equity.measure.*; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2927 
    3028/** 
    … …  
    3432public class CompanyProfileImpl implements CompanyProfile { 
    3533 
    36     private final Equity equity; 
     34    private final Stock stock; 
    3735    private final TradingData trading; 
    3836    private final AccountingData accounting; 
    3937 
    40     public CompanyProfileImpl(Equity equity, TradingData trading, AccountingData accounting) { 
    41         this.equity = equity; 
     38    public CompanyProfileImpl(Stock stock, TradingData trading, AccountingData accounting) { 
     39        this.stock = stock; 
    4240        this.trading = trading; 
    4341        this.accounting = accounting; 
    … …  
    4543 
    4644    @Override 
    47     public Equity getEquity() { 
    48         return equity; 
     45    public Stock getStock() { 
     46        return stock; 
    4947    } 
    5048 
    … …  
    6159    @Override 
    6260    public String toString() { 
    63         return String.format("[%s]: %s %s", equity, trading, accounting); 
     61        return String.format("[%s]: %s %s", stock, trading, accounting); 
    6462    } 
    6563} 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/bucketing/Bucket.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.equity.bucketing; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import java.util.Collections; 
    2727import java.util.HashSet; 
    … …  
    3737 
    3838    private final K key; 
    39     private final HashSet<Equity> equities; 
     39    private final HashSet<Stock> equities; 
    4040 
    41     public Bucket(K key, Set<Equity> equities) { 
     41    public Bucket(K key, Set<Stock> equities) { 
    4242        this.key = key; 
    43         this.equities = new HashSet<Equity>(equities); 
     43        this.equities = new HashSet<Stock>(equities); 
    4444    } 
    4545 
    … …  
    4848    } 
    4949 
    50     public Set<Equity> getEquitySet() { 
     50    public Set<Stock> getStocks() { 
    5151        return Collections.unmodifiableSet(equities); 
    5252    } 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/bucketing/Bucketing.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.equity.bucketing; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import java.util.Map; 
    2727import java.util.Set; 
    … …  
    4949     * @return the buckets of equities 
    5050     */ 
    51     public Map<K, Bucket<K>> sort(Set<Equity> equities); 
     51    public Map<K, Bucket<K>> sort(Set<Stock> equities); 
    5252} 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/filter/companyhistories/EmptyHistoryFilter.java

    r1491 r1495  
    4343                public boolean evaluate(CompanyHistory history) { 
    4444                    if (history.getProfiles().size() == 0) { 
    45                         logger.warn(String.format("Removed empty history (%s) !", history.getEquity())); 
     45                        logger.warn(String.format("Removed empty history (%s) !", history.getStock())); 
    4646                        return false; 
    4747                    } 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/filter/companyhistory/CompanyHistoryPredicateFilter.java

    r1488 r1495  
    4949 
    5050        return new CompanyHistoryImpl( 
    51             history.getEquity(), 
     51            history.getStock(), 
    5252            history.getCompanyInfo(), 
    5353            new SequentialCache<CompanyProfile>() { 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/filter/equities/EquitiesFilter.java

    r1492 r1495  
    2525import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    2626import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2828import java.util.Collection; 
    2929import java.util.Set; 
    … …  
    3838public interface EquitiesFilter { 
    3939 
    40     public Set<Equity> getFilteredEquities(RandomAccessCache<MarketSnapshot> marketSnapshotCache, 
    41                                            Collection<Equity> equities); 
     40    public Set<Stock> getFilteredEquities(RandomAccessCache<MarketSnapshot> marketSnapshotCache, 
     41                                           Collection<Stock> equities); 
    4242} 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/filter/equities/LiquidityFilter.java

    r1492 r1495  
    2828import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    2929import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3131import com.numericalmethod.suanshu.number.DoubleUtils; 
    3232import com.numericalmethod.suanshu.stats.descriptive.moment.Mean; 
    33 import java.util.ArrayList; 
    34 import java.util.Collection; 
    35 import java.util.HashSet; 
    36 import java.util.Iterator; 
    37 import java.util.List; 
    38 import java.util.Set; 
     33import java.util.*; 
    3934import org.joda.time.DateTime; 
    4035 
    … …  
    7570 
    7671    @Override 
    77     public Set<Equity> getFilteredEquities( 
     72    public Set<Stock> getFilteredEquities( 
    7873        RandomAccessCache<MarketSnapshot> marketSnapshotCache, 
    79         Collection<Equity> equities) { 
    80         Set<Equity> outputEquities = new HashSet<Equity>(); 
    81         for (Equity equity : equities) { 
     74        Collection<Stock> stocks) { 
     75        Set<Stock> outputEquities = new HashSet<Stock>(); 
     76        for (Stock stock : stocks) { 
    8277 
    83             if (testLiquidity(equity, marketSnapshotCache.iteratorBetween(startDate, endDate))) { 
    84                 outputEquities.add(equity); 
     78            if (testLiquidity(stock, marketSnapshotCache.iteratorBetween(startDate, endDate))) { 
     79                outputEquities.add(stock); 
    8580            } 
    8681        } 
    … …  
    8984    } 
    9085 
    91     private boolean testLiquidity(Equity equity, 
    92         Iterator<TimedEntry<MarketSnapshot>> snapshotsIterator) { 
     86    private boolean testLiquidity(Stock stock, 
     87                                  Iterator<TimedEntry<MarketSnapshot>> snapshotsIterator) { 
    9388        List<Double> dollarVolumes = new ArrayList<Double>(); 
    9489        List<Double> prices = new ArrayList<Double>(); 
    … …  
    9691        while (snapshotsIterator.hasNext()) { 
    9792            MarketSnapshot snapshot = snapshotsIterator.next().getData(); 
    98             double price = snapshot.getProfile(equity).getMeasureValue(new TradedPrice()); 
    99             double volume = snapshot.getProfile(equity).getMeasureValue(new TradedVolume()); 
     93            double price = snapshot.getProfile(stock).getMeasureValue(new TradedPrice()); 
     94            double volume = snapshot.getProfile(stock).getMeasureValue(new TradedVolume()); 
    10095            double dollarVolume = price * volume; 
    10196 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/measure/StockMeasure.java

    r1484 r1495  
    2727 * @author Johannes Lehmann 
    2828 */ 
    29 public class EquityMeasure extends CompanyMeasure { 
     29public class StockMeasure extends CompanyMeasure { 
    3030 
    3131    @Override 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/snapshot/MarketSnapshot.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.equity.CompanyProfile; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    2828import com.numericalmethod.suanshu.misc.ArgumentAssertion; 
    29 import java.util.Collections; 
    30 import java.util.HashSet; 
    31 import java.util.List; 
    32 import java.util.Map; 
    33 import java.util.Set; 
     29import java.util.*; 
    3430 
    3531/** 
    … …  
    4036public class MarketSnapshot { 
    4137 
    42     private final double marketValue; // the value of a market index or benchmark 
     38    private final double benchmark; // the value of a market index or benchmark 
    4339    private final double riskFreeRate; // the risk-free interest rate 
    44     private final List<CompanyProfile> profiles; // data of each company at the snapshot time 
    45     private final Map<Equity, CompanyProfile> map = newHashMap(); 
     40    private final Map<Stock, CompanyProfile> map = newHashMap(); 
    4641 
    4742    /** 
    48      * Creates an instance given the values of the market and companies. 
     43     * Creates an instance given the values of the benchmark and companies. 
    4944     * 
    50      * @param marketValue  the market value, e.g., HS index value 
     45     * @param benchmark    the market value, e.g., HS index value 
    5146     * @param riskFreeRate the risk-free rate 
    52      * @param profiles     the company profiles 
     47     * @param profiles     the data of each company at the snapshot time 
    5348     */ 
    54     public MarketSnapshot(double marketValue, double riskFreeRate, List<CompanyProfile> profiles) { 
    55         this.marketValue = marketValue; 
     49    public MarketSnapshot(double benchmark, double riskFreeRate, Collection<CompanyProfile> profiles) { 
     50        this.benchmark = benchmark; 
    5651        this.riskFreeRate = riskFreeRate; 
    57         this.profiles = profiles; 
    5852 
    5953        for (CompanyProfile profile : profiles) { 
    60             Equity equity = profile.getEquity(); 
    61             ArgumentAssertion.assertTrue(!map.containsKey(equity), 
    62                                          "duplicate product (%s) in the profile list", equity); 
    63             map.put(profile.getEquity(), profile); 
     54            Stock stock = profile.getStock(); 
     55            ArgumentAssertion.assertTrue(!map.containsKey(stock), 
     56                                         "duplicate product (%s) in the profile list", stock); 
     57            map.put(profile.getStock(), profile); 
    6458        } 
    6559    } 
    6660 
    67     public double getMarketValue() { 
    68         return marketValue; 
     61    public double getBenchmark() { 
     62        return benchmark; 
    6963    } 
    7064 
    … …  
    7367    } 
    7468 
    75     public List<CompanyProfile> getProfiles() { 
    76         return Collections.unmodifiableList(profiles); 
     69    public Set<Stock> getEquities() { 
     70        return Collections.unmodifiableSet(map.keySet()); 
    7771    } 
    7872 
    79     public CompanyProfile getProfile(Equity equity) { 
    80         return map.get(equity); 
     73    public Collection<CompanyProfile> getProfiles() { 
     74        return Collections.unmodifiableCollection(map.values()); 
    8175    } 
    8276 
    83     public Set<Equity> getEquities() { 
    84         Set<Equity> equities = new HashSet<Equity>(); 
    85         for (CompanyProfile profile : profiles) { 
    86             equities.add(profile.getEquity()); 
    87         } 
    88         return equities; 
     77    public CompanyProfile getProfile(Stock stock) { 
     78        return map.get(stock); 
    8979    } 
    9080} 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/snapshot/MarketSnapshotUtils.java

    r1366 r1495  
    3232import com.numericalmethod.algoquant.data.equity.CompanyProfile; 
    3333import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    34 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     34import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3535import java.util.ArrayList; 
    3636import java.util.List; 
    … …  
    9595    } 
    9696 
    97     public static Set<Equity> getEquitiesFromFirstSnapshot( 
     97    public static Set<Stock> getEquitiesFromFirstSnapshot( 
    9898        SequentialCache<MarketSnapshot> marketSnapshots) { 
    9999        return CacheUtils.getFirstEntry(marketSnapshots).getData().getEquities(); 

  • core/src/main/java/com/numericalmethod/algoquant/data/equity/snapshot/MonthlyDataFromMarketSnapshots.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.cache.processor.sampler.EquiTimeSampler; 
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.model.signal.movingwindow.MovingWindowByPeriod; 
    30 import java.util.ArrayList; 
    31 import java.util.Collections; 
    32 import java.util.List; 
     30import java.util.*; 
    3331import org.joda.time.DateTime; 
    3432import org.joda.time.Period; 
    … …  
    4745    private final List<Double> priceSeries; 
    4846 
    49     public MonthlyDataFromMarketSnapshots(SequentialCache<MarketSnapshot> snapshotsCache, 
    50         Equity equity) { 
    51         monthlyMarketSnapshots = getMonthlyFromDailySnapshots(snapshotsCache); 
     47    public MonthlyDataFromMarketSnapshots(SequentialCache<MarketSnapshot> snapshots, 
     48                                          Stock stock) { 
     49        monthlyMarketSnapshots = new EquiTimeSampler<MarketSnapshot>(Period.months(1)).doProcess(snapshots); 
    5250        times = new ArrayList<DateTime>(); 
    5351        market = new ArrayList<Double>(); 
    … …  
    5856            MarketSnapshot snapshot = entry.getData(); 
    5957            times.add(entry.getTime()); 
    60             market.add(snapshot.getMarketValue()); 
     58            market.add(snapshot.getBenchmark()); 
    6159            rates.add(snapshot.getRiskFreeRate()); 
    62             priceSeries.add(snapshot.getProfile(equity).getPrice()); 
     60            priceSeries.add(snapshot.getProfile(stock).getPrice()); 
    6361        } 
    64     } 
    65  
    66     private static SequentialCache<MarketSnapshot> getMonthlyFromDailySnapshots( 
    67         SequentialCache<MarketSnapshot> snapshots) { 
    68         return new EquiTimeSampler<MarketSnapshot>(Period.months(1)).doProcess(snapshots); 
    6962    } 
    7063 
    … …  
    8578 
    8679    /** 
    87      * @return A map which for each equity contains the price of that equity for each of the times 
     80     * @return A map which for each stock contains the price of that stock for each of the times 
    8881     *         returned by {@code getTimes()}. 
    8982     */ 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/DataSources.java

    r1430 r1495  
    3131import com.numericalmethod.algoquant.data.type.Depth; 
    3232import com.numericalmethod.algoquant.execution.product.Product; 
    33 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     33import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3434import com.numericalmethod.suanshu.misc.ArgumentAssertion; 
    3535 
    … …  
    5656     */ 
    5757    GAIN_CAPITAL { 
    58         @Override 
    59         public String getDefaultDataFolder() { 
    60             return Config.INSTANCE.getString(ConfigProperties.DATA_GAINCAPITAL.getPropertyName()); 
    61         } 
     58            @Override 
     59            public String getDefaultDataFolder() { 
     60                return Config.INSTANCE.getString(ConfigProperties.DATA_GAINCAPITAL.getPropertyName()); 
     61            } 
    6262 
    63         @Override 
    64         public CacheFactory<Depth> forProduct(Product product, String dataFolder) { 
    65             return new GainCapitalFx(product, dataFolder); 
    66         } 
    67     }, 
     63            @Override 
     64            public CacheFactory<Depth> forProduct(Product product, String dataFolder) { 
     65                return new GainCapitalFx(product, dataFolder); 
     66            } 
     67        }, 
    6868    /** 
    6969     * Bloomberg tick data. 
    … …  
    7272     */ 
    7373    BLOOMBERG { 
    74         @Override 
    75         public String getDefaultDataFolder() { 
    76             return Config.INSTANCE.getString(ConfigProperties.DATA_BLOOMBERG.getPropertyName()); 
    77         } 
     74            @Override 
     75            public String getDefaultDataFolder() { 
     76                return Config.INSTANCE.getString(ConfigProperties.DATA_BLOOMBERG.getPropertyName()); 
     77            } 
    7878 
    79         @Override 
    80         public CacheFactory<Depth> forProduct(Product product, String dataFolder) { 
    81             return new BloombergTickData(product, dataFolder); 
    82         } 
    83     }, 
     79            @Override 
     80            public CacheFactory<Depth> forProduct(Product product, String dataFolder) { 
     81                return new BloombergTickData(product, dataFolder); 
     82            } 
     83        }, 
    8484    /** 
    8585     * Yahoo! data. 
    … …  
    8888     */ 
    8989    YAHOO { 
    90         @Override 
    91         public String getDefaultDataFolder() { 
    92             return Config.INSTANCE.getString(ConfigProperties.DATA_YAHOO.getPropertyName()); 
    93         } 
     90            @Override 
     91            public String getDefaultDataFolder() { 
     92                return Config.INSTANCE.getString(ConfigProperties.DATA_YAHOO.getPropertyName()); 
     93            } 
    9494 
    95         @Override 
    96         public CacheFactory<Depth> forProduct(Product product, String dataFolder) { 
    97             ArgumentAssertion.assertTrue( 
    98                 product.is(Equity.class), 
    99                 "YahooEOD supports equity class only"); 
     95            @Override 
     96            public CacheFactory<Depth> forProduct(Product product, String dataFolder) { 
     97                ArgumentAssertion.assertTrue( 
     98                    product.is(Stock.class), 
     99                    "YahooEOD supports stock class only"); 
    100100 
    101             return DepthCacheUtils.fromEquityEODCacheFactory( 
    102                 product, 
    103                 new YahooEOD(product.as(Equity.class), dataFolder, dataFolder)); 
    104         } 
    105     }; 
     101                return DepthCacheUtils.fromStockEODCacheFactory( 
     102                    product, 
     103                    new YahooEOD(product.as(Stock.class), dataFolder, dataFolder)); 
     104            } 
     105        }; 
    106106 
    107107    /** 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/DepthCacheUtils.java

    r1476 r1495  
    3131import com.numericalmethod.algoquant.data.cache.processor.transformer.EntryDataTransformer; 
    3232import com.numericalmethod.algoquant.data.type.Depth; 
    33 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     33import com.numericalmethod.algoquant.data.type.StockEOD; 
    3434import com.numericalmethod.algoquant.execution.product.Product; 
    3535import com.numericalmethod.algoquant.execution.simulation.DepthCachesLoader; 
    … …  
    5555     * Same as calling 
    5656     * <pre>{@code 
    57      * fromEquityEODCache(product, cache, EquityEOD2Depth.Type.ADJ_CLOSE); 
     57     * fromStockEODCache(product, cache, StockEOD2Depth.Type.ADJ_CLOSE); 
    5858     * }</pre> 
    5959     * 
    60      * @param product the equity product 
    61      * @param cache   the cache containing {@code EquityEOD} 
     60     * @param product the stock product 
     61     * @param cache   the cache containing {@code StockEOD} 
    6262     * @return a cache containing transformed {@code Depth} 
    6363     * 
    64      * @see #fromEquityEODCache(com.numericalmethod.algoquant.execution.product.Product, 
     64     * @see #fromStockEODCache(com.numericalmethod.algoquant.execution.product.Product, 
    6565     * com.numericalmethod.algoquant.data.cache.SequentialCache, 
    66      * com.numericalmethod.algoquant.data.historicaldata.EquityEOD2Depth.Type) 
     66     * com.numericalmethod.algoquant.data.historicaldata.StockEOD2Depth.Type) 
    6767     */ 
    68     public static SequentialCache<Depth> fromEquityEODCache( 
    69         Product product, 
    70         SequentialCache<EquityEOD> cache) { 
    71         return fromEquityEODCache(product, cache, EquityEOD2Depth.Type.ADJ_CLOSE); 
     68    public static SequentialCache<Depth> fromStockEODCache(Product product, 
     69                                                           SequentialCache<StockEOD> cache) { 
     70        return fromStockEODCache(product, cache, StockEOD2Depth.Type.ADJ_CLOSE); 
    7271    } 
    7372 
    7473    /** 
    75      * Transforms a cache of {@code EquityEOD} to a cache of {@code Depth}, 
     74     * Transforms a cache of {@code StockEOD} to a cache of {@code Depth}, 
    7675     * usually for simulation purpose. 
    7776     * 
    78      * @param product        the equity product 
    79      * @param cache          the cache containing {@code EquityEOD} 
    80      * @param conversionType how each {@code EquityEOD} item is transformed to a {@code Depth} 
     77     * @param product        the stock product 
     78     * @param cache          the cache containing {@code StockEOD} 
     79     * @param conversionType how each {@code StockEOD} item is transformed to a {@code Depth} 
    8180     * @return a cache containing transformed {@code Depth} 
    8281     */ 
    83     public static SequentialCache<Depth> fromEquityEODCache( 
    84         Product product, 
    85         SequentialCache<EquityEOD> cache, 
    86         EquityEOD2Depth.Type conversionType) { 
    87         DataTransformer<EquityEOD, Depth> transformer = new EquityEOD2Depth(product, conversionType); 
    88         CacheProcessor<EquityEOD, Depth> processor = new EntryDataTransformer<EquityEOD, Depth>(transformer); 
     82    public static SequentialCache<Depth> fromStockEODCache(Product product, 
     83                                                           SequentialCache<StockEOD> cache, 
     84                                                           StockEOD2Depth.Type conversionType) { 
     85        DataTransformer<StockEOD, Depth> transformer = new StockEOD2Depth(product, conversionType); 
     86        CacheProcessor<StockEOD, Depth> processor = new EntryDataTransformer<StockEOD, Depth>(transformer); 
    8987 
    9088        return processor.doProcess(cache); 
    … …  
    9492     * Same as calling 
    9593     * <pre>{@code 
    96      * fromEquityEODCacheFactory(product, factory, EquityEOD2Depth.Type.ADJ_CLOSE); 
     94     * fromStockEODCacheFactory(product, factory, StockEOD2Depth.Type.ADJ_CLOSE); 
    9795     * }</pre> 
    9896     * 
    99      * @param product the equity product 
    100      * @param factory the cache factory that creates cache of {@code EquityEOD} 
     97     * @param product the stock product 
     98     * @param factory the cache factory that creates cache of {@code StockEOD} 
    10199     * @return a cache factory that creates transformed {@code Depth} 
    102100     * 
    103      * @see #fromEquityEODCacheFactory(com.numericalmethod.algoquant.execution.product.Product, 
     101     * @see #fromStockEODCacheFactory(com.numericalmethod.algoquant.execution.product.Product, 
    104102     * com.numericalmethod.algoquant.data.cache.CacheFactory, 
    105      * com.numericalmethod.algoquant.data.historicaldata.EquityEOD2Depth.Type) 
     103     * com.numericalmethod.algoquant.data.historicaldata.StockEOD2Depth.Type) 
    106104     */ 
    107     public static CacheFactory<Depth> fromEquityEODCacheFactory( 
    108         Product product, 
    109         CacheFactory<EquityEOD> factory) { 
    110         return fromEquityEODCacheFactory(product, factory, EquityEOD2Depth.Type.ADJ_CLOSE); 
     105    public static CacheFactory<Depth> fromStockEODCacheFactory(Product product, 
     106                                                               CacheFactory<StockEOD> factory) { 
     107        return fromStockEODCacheFactory(product, factory, StockEOD2Depth.Type.ADJ_CLOSE); 
    111108    } 
    112109 
    113110    /** 
    114      * Transforms a cache factory of {@code EquityEOD} to a cache factory of 
     111     * Transforms a cache factory of {@code StockEOD} to a cache factory of 
    115112     * {@code Depth}, usually for simulation purpose. 
    116113     * 
    117      * @param product        the equity product 
    118      * @param factory        the cache factory that creates cache of {@code EquityEOD} 
    119      * @param conversionType how each {@code EquityEOD} item is transformed to a {@code Depth} 
     114     * @param product        the stock product 
     115     * @param factory        the cache factory that creates cache of {@code StockEOD} 
     116     * @param conversionType how each {@code StockEOD} item is transformed to a {@code Depth} 
    120117     * @return a cache factory that creates transformed {@code Depth} 
    121118     */ 
    122     public static CacheFactory<Depth> fromEquityEODCacheFactory( 
    123         final Product product, 
    124         final CacheFactory<EquityEOD> factory, 
    125         final EquityEOD2Depth.Type conversionType) { 
     119    public static CacheFactory<Depth> fromStockEODCacheFactory(final Product product, 
     120                                                               final CacheFactory<StockEOD> factory, 
     121                                                               final StockEOD2Depth.Type conversionType) { 
    126122        return new CacheFactory<Depth>() { 
    127123            @Override 
    128124            public SequentialCache<Depth> getCache(DateTime begin, DateTime end) { 
    129                 return fromEquityEODCache(product, factory.getCache(begin, end), conversionType); 
     125                return fromStockEODCache(product, factory.getCache(begin, end), conversionType); 
    130126            } 
    131127        }; 
    … …  
    141137     * @return the returns matrix 
    142138     */ 
    143     public static Matrix loadReturnsMatrix( 
    144         DataSource dataSource, 
    145         List<Product> products, 
    146         DateTime begin, 
    147         DateTime end) { 
    148         DepthCaches caches = 
    149             new DepthCachesLoader(dataSource).loadCaches(products, begin, end); 
     139    public static Matrix loadReturnsMatrix(DataSource dataSource, 
     140                                           List<Product> products, 
     141                                           DateTime begin, 
     142                                           DateTime end) { 
     143        DepthCaches caches = new DepthCachesLoader(dataSource).loadCaches(products, begin, end); 
    150144 
    151145        List<SequentialCache<Double>> doubleCaches = 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/StockEOD2Depth.java

    r1484 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.cache.processor.transformer.DataTransformer; 
    26 import com.numericalmethod.algoquant.data.type.Depth; 
    27 import com.numericalmethod.algoquant.data.type.DepthUtils; 
    28 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     26import com.numericalmethod.algoquant.data.type.*; 
    2927import com.numericalmethod.algoquant.execution.product.Product; 
    3028 
    3129/** 
    3230 * The values in this enum implements {@link DataTransformer} interface 
    33  * for converting {@link EquityEOD} to {@link Depth}. 
     31 * for converting {@link StockEOD} to {@link Depth}. 
    3432 * 
    3533 * @author Ken Yiu 
    3634 */ 
    37 public class EquityEOD2Depth implements DataTransformer<EquityEOD, Depth> { 
     35public class StockEOD2Depth implements DataTransformer<StockEOD, Depth> { 
    3836 
    3937    public static enum Type { 
    … …  
    4341         */ 
    4442        OPEN { 
    45             @Override 
    46             double getValue(EquityEOD equityEod) { 
    47                 return equityEod.getOpen(); 
    48             } 
    49         }, 
     43                @Override 
     44                double getValue(StockEOD stockEod) { 
     45                    return stockEod.getOpen(); 
     46                } 
     47            }, 
    5048        /** 
    5149         * /** 
    … …  
    5351         */ 
    5452        CLOSE { 
    55             @Override 
    56             double getValue(EquityEOD equityEod) { 
    57                 return equityEod.getClose(); 
    58             } 
    59         }, 
     53                @Override 
     54                double getValue(StockEOD stockEod) { 
     55                    return stockEod.getClose(); 
     56                } 
     57            }, 
    6058        /** 
    6159         * The source will return "adjusted close" price of the EOD. 
    6260         */ 
    6361        ADJ_CLOSE { 
    64             @Override 
    65             double getValue(EquityEOD equityEod) { 
    66                 return equityEod.getAdjClose(); 
    67             } 
    68         }; 
     62                @Override 
     63                double getValue(StockEOD stockEod) { 
     64                    return stockEod.getAdjClose(); 
     65                } 
     66            }; 
    6967 
    70         abstract double getValue(EquityEOD equityEod); 
     68        abstract double getValue(StockEOD stockEod); 
    7169    } 
     70 
    7271    private final Product product; 
    7372    private final Type type; 
    … …  
    7978     * @param type    conversion type 
    8079     */ 
    81     public EquityEOD2Depth(Product product, Type type) { 
     80    public StockEOD2Depth(Product product, Type type) { 
    8281        this.product = product; 
    8382        this.type = type; 
    … …  
    8584 
    8685    @Override 
    87     public Depth transform(EquityEOD equityEod) { 
    88         return DepthUtils.newSinglePriceDepth(product, type.getValue(equityEod)); 
     86    public Depth transform(StockEOD stockEod) { 
     87        return DepthUtils.newSinglePriceDepth(product, type.getValue(stockEod)); 
    8988    } 
    9089} 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/compustat/AccountingUpdate.java

    r1366 r1495  
    5050        I 
    5151    } 
     52 
    5253    private static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormat.forPattern("yyyyMMdd"); 
    5354    private final String stockid; 
    … …  
    6061    private final long nCommonStocks; 
    6162    private final long nTreasuryStocks; 
    62     private final double equity; 
     63    private final double stock; 
    6364    private final double revenue; 
    6465    private final double sales; 
    … …  
    8485        long nCommonStocks = parseLong((String) map.get("CStock")); 
    8586        long nTreasuryStocks = parseLong((String) map.get("TStock")); 
    86         long equity = parseLong((String) map.get("Equity")); 
     87        long stock = parseLong((String) map.get("Equity")); 
    8788        long revenue = parseLong((String) map.get("Revenue")); 
    8889        long sales = parseLong((String) map.get("Sales")); 
    … …  
    9798        long netDebt = parseLong((String) map.get("NetDebt")); 
    9899 
    99         return new AccountingUpdate(stockid, fydate, popsrc, denomination, asset, liability, nPreferredStocks, nCommonStocks, nTreasuryStocks, equity, revenue, sales, expense, earnings, earningAfterDepreciation, interest, income, tax, dividend, cashflow, netDebt); 
     100        return new AccountingUpdate(stockid, fydate, popsrc, denomination, asset, liability, nPreferredStocks, nCommonStocks, nTreasuryStocks, stock, revenue, sales, expense, earnings, earningAfterDepreciation, interest, income, tax, dividend, cashflow, netDebt); 
    100101    } 
    101102 
    … …  
    110111        long nCommonStocks, 
    111112        long nTreasuryStocks, 
    112         double equity, 
     113        double stock, 
    113114        double revenue, 
    114115        double sales, 
    … …  
    131132        this.nCommonStocks = nCommonStocks; 
    132133        this.nTreasuryStocks = nTreasuryStocks; 
    133         this.equity = equity; 
     134        this.stock = stock; 
    134135        this.revenue = revenue; 
    135136        this.sales = sales; 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/compustat/CompanyHistoryDB.java

    r1401 r1495  
    2828import com.numericalmethod.algoquant.data.equity.CompanyInfo; 
    2929import com.numericalmethod.algoquant.data.equity.measure.AccountingData; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3131import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3232import static com.numericalmethod.nmutils.NMUtils.*; 
    … …  
    154154 
    155155        return new CompanyHistoryImpl( 
    156             new Equity(company.getStockId(), company.getExchange()), // Note: Symbols from Compustat are sometimes missing, use stockId instead 
     156            new Stock(company.getStockId(), company.getExchange()), // Note: Symbols from Compustat are sometimes missing, use stockId instead 
    157157            company, 
    158158            prices, 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/MultipleYahooEOD.java

    r1366 r1495  
    2727import com.numericalmethod.algoquant.data.cache.processor.transformer.DoubleEntryTransformer; 
    2828import com.numericalmethod.algoquant.data.cache.processor.transformer.DoubleEntryTransformers; 
    29 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.data.type.StockEOD; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3131import java.util.ArrayList; 
    3232import java.util.List; 
    … …  
    3939public class MultipleYahooEOD extends VectorCache<Double> { 
    4040 
    41     public MultipleYahooEOD(Equity[] equity, DateTime begin, DateTime end, 
    42         DoubleEntryTransformer<EquityEOD> converter, 
    43         String dirIn, String dirOut) { 
    44         super(getConstituents(equity, begin, end, converter, dirIn, dirOut)); 
     41    public MultipleYahooEOD(Stock[] stock, DateTime begin, DateTime end, 
     42                            DoubleEntryTransformer<StockEOD> converter, 
     43                            String dirIn, String dirOut) { 
     44        super(getConstituents(stock, begin, end, converter, dirIn, dirOut)); 
    4545    } 
    4646 
    47     public MultipleYahooEOD(Equity[] equity, DateTime begin, DateTime end, 
    48         String dirIn, String dirOut) { 
    49         this(equity, begin, end, DoubleEntryTransformers.EQUITYEOD, dirIn, dirOut); 
     47    public MultipleYahooEOD(Stock[] stock, DateTime begin, DateTime end, 
     48                            String dirIn, String dirOut) { 
     49        this(stock, begin, end, DoubleEntryTransformers.STOCK_EOD, dirIn, dirOut); 
    5050    } 
    5151 
    5252    private static List<SequentialCache<Double>> getConstituents( 
    53         Equity[] equity, DateTime begin, DateTime end, 
    54         DoubleEntryTransformer<EquityEOD> transformer, 
     53        Stock[] stocks, DateTime begin, DateTime end, 
     54        DoubleEntryTransformer<StockEOD> transformer, 
    5555        String dirIn, String dirOut) { 
    56         final int length = equity.length; 
     56        final int length = stocks.length; 
    5757        List<SequentialCache<Double>> caches = new ArrayList<SequentialCache<Double>>(length); 
    5858        for (int i = 0; i < length; ++i) { 
    5959            YahooEOD source = new YahooEOD( 
    60                 equity[i], 
     60                stocks[i], 
    6161                dirIn, 
    6262                dirOut); 
    6363 
    64             SequentialCache<EquityEOD> seq = source.getCache(begin, end); 
     64            SequentialCache<StockEOD> seq = source.getCache(begin, end); 
    6565 
    6666            SequentialCache<Double> doubleCache = transformer.doProcess(seq); 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooEOD.java

    r1366 r1495  
    3030import com.numericalmethod.algoquant.data.structure.TimedBuffer; 
    3131import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    32 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    33 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     32import com.numericalmethod.algoquant.data.type.StockEOD; 
    3433import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     34import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3535import static com.numericalmethod.nmutils.NMUtils.getClassLogger; 
    3636import com.numericalmethod.nmutils.iterator.ReadOnlyIterator; 
    … …  
    4848 * @author Haksun Li 
    4949 */ 
    50 public class YahooEOD implements CacheFactory<EquityEOD> { 
     50public class YahooEOD implements CacheFactory<StockEOD> { 
    5151 
    5252    private static final Logger logger = getClassLogger(); 
    53     private final Equity equity; 
     53    private final Stock stock; 
    5454    private final String dirIn; 
    5555    private final String dirOut; 
    56     private final TimedBuffer<EquityEOD> buffer = new TimedBuffer<EquityEOD>(); 
     56    private final TimedBuffer<StockEOD> buffer = new TimedBuffer<StockEOD>(); 
    5757 
    5858    /** 
    … …  
    6161     * from the local directory, data will be downloaded from Yahoo! website. 
    6262     * 
    63      * @param equity the equity product 
     63     * @param stock  the stock product 
    6464     * @param dirIn  the directory where the local data is saved 
    6565     * @param dirOut the directory where the loaded data is saved (for future use) 
    6666     */ 
    67     public YahooEOD(Equity equity, String dirIn, String dirOut) { 
    68         this.equity = equity; 
     67    public YahooEOD(Stock stock, String dirIn, String dirOut) { 
     68        this.stock = stock; 
    6969        this.dirIn = dirIn; 
    7070        this.dirOut = dirOut; // TODO: 100% of the time, this is the same as dirIn, so merge them 
    7171    } 
    7272 
    73     public YahooEOD(Equity equity, String dirIn) { 
    74         this(equity, dirIn, null); 
    75     } 
    76  
    77     public YahooEOD(Equity equity) { 
    78         this(equity, null, null); 
     73    public YahooEOD(Stock stock, String dirIn) { 
     74        this(stock, dirIn, null); 
     75    } 
     76 
     77    public YahooEOD(Stock stock) { 
     78        this(stock, null, null); 
    7979    } 
    8080 
    8181    @Override 
    82     public SequentialCache<EquityEOD> getCache(DateTime begin, DateTime end) { 
    83         final DateTime cacheBegin = roundTime(begin, equity.getExchange()); 
    84         final DateTime cacheEnd = roundTime(end, equity.getExchange()); 
     82    public SequentialCache<StockEOD> getCache(DateTime begin, DateTime end) { 
     83        final DateTime cacheBegin = roundTime(begin, stock.getExchange()); 
     84        final DateTime cacheEnd = roundTime(end, stock.getExchange()); 
    8585 
    8686        if (!hasBufferedDataForInterval(cacheBegin, cacheEnd)) { 
    … …  
    8888        } 
    8989 
    90         return new SequentialCache<EquityEOD>() { 
     90        return new SequentialCache<StockEOD>() { 
    9191 
    9292            @Override 
    93             public Iterator<TimedEntry<EquityEOD>> iterator() { 
    94                 return new ReadOnlyIterator<TimedEntry<EquityEOD>>( 
    95                         buffer.iteratorBetween(cacheBegin, cacheEnd.plus(1))); // including cacheEnd 
     93            public Iterator<TimedEntry<StockEOD>> iterator() { 
     94                return new ReadOnlyIterator<TimedEntry<StockEOD>>( 
     95                    buffer.iteratorBetween(cacheBegin, cacheEnd.plus(1))); // including cacheEnd 
    9696            } 
    9797        }; 
    … …  
    104104 
    105105    /** 
    106      * Rounds the time to the trading hour close for an equity. 
     106     * Rounds the time to the trading hour close for an stock. 
    107107     */ 
    108108    private static DateTime roundTime(DateTime time, Exchange exchange) { 
    … …  
    124124 
    125125    private boolean loadBufferFromFile(DateTime begin, DateTime end) { 
    126         String fileName = String.format("%s/%s.csv.zip", dirIn, equity.getSymbol()); 
     126        String fileName = String.format("%s/%s.csv.zip", dirIn, stock.getSymbol()); 
    127127        logger.debug(String.format("reading Yahoo! data from file %s from %s to %s", 
    128128                                   fileName, begin, end)); 
    … …  
    153153                for (; row != null && !row.timestamp.isAfter(businessDayEnd); row = reader.next()) { 
    154154                    buffer.put(row.timestamp, 
    155                                new EquityEOD(row.open, row.high, row.low, row.close, row.volume, row.adjClose)); 
     155                               new StockEOD(row.open, row.high, row.low, row.close, row.volume, row.adjClose)); 
    156156                    if (!row.timestamp.isBefore(businessDayEnd)) { // got enough data 
    157157                        /* 
    … …  
    181181 
    182182    private DateTime findFirstBusinessDay(DateTime begin) { 
    183         Holidays holidays = ExchangeHolidays.forExchange(equity.getExchange()); 
     183        Holidays holidays = ExchangeHolidays.forExchange(stock.getExchange()); 
    184184        DateTime businessDayBegin = begin; 
    185185        while (holidays.isHoliday(businessDayBegin)) { 
    … …  
    191191 
    192192    private DateTime findLastBusinessDay(DateTime end) { 
    193         Holidays holidays = ExchangeHolidays.forExchange(equity.getExchange()); 
     193        Holidays holidays = ExchangeHolidays.forExchange(stock.getExchange()); 
    194194        DateTime businessDayEnd = end; 
    195195        while (holidays.isHoliday(businessDayEnd)) { 
    … …  
    205205        logger.debug(String.format("reading Yahoo! data from the Internet from %s to %s", 
    206206                                   begin.toString(), end.toString())); 
    207         YahooEODWebDownloader webReader = new YahooEODWebDownloader(equity); 
    208         SequentialCache<EquityEOD> webCache = webReader.getCache(begin, end); 
    209         for (TimedEntry<EquityEOD> entry : webCache) { 
     207        YahooEODWebDownloader webReader = new YahooEODWebDownloader(stock); 
     208        SequentialCache<StockEOD> webCache = webReader.getCache(begin, end); 
     209        for (TimedEntry<StockEOD> entry : webCache) { 
    210210            buffer.put(entry.getTime(), entry.getData()); 
    211211        } 
    … …  
    216216    } 
    217217 
    218     private void saveCacheToFile(SequentialCache<EquityEOD> cache) { 
     218    private void saveCacheToFile(SequentialCache<StockEOD> cache) { 
    219219        try { 
    220220            YahooEODCsvZipFileWriter writer = new YahooEODCsvZipFileWriter(dirOut); 
    221             writer.save(equity, cache); 
     221            writer.save(stock, cache); 
    222222        } catch (Exception ex) {//the code is able to continue despite not being able to saveFromWeb data 
    223223            logger.warn(String.format("unable to write the Yahoo! data to %s", dirOut), ex); 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooEODCsvZipFileReader.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    26 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     26import com.numericalmethod.algoquant.data.type.StockEOD; 
    2727import static com.numericalmethod.nmutils.NMUtils.*; 
    2828import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    4242 
    4343/** 
    44  * This reads a Yahoo! end of day equity data csv.zip file. 
     44 * This reads a Yahoo! end of day stock data csv.zip file. 
    4545 * 
    4646 * @author Simon Lui 
    … …  
    7474        } 
    7575 
    76         YahooRow(TimedEntry<EquityEOD> equityEOD) { 
    77             timestamp = new DateTime(equityEOD.getTime()); 
    78             open = equityEOD.getData().getOpen(); 
    79             high = equityEOD.getData().getHigh(); 
    80             low = equityEOD.getData().getLow(); 
    81             close = equityEOD.getData().getClose(); 
    82             volume = equityEOD.getData().getVolume(); 
    83             adjClose = equityEOD.getData().getAdjClose(); 
     76        YahooRow(TimedEntry<StockEOD> stockEOD) { 
     77            timestamp = new DateTime(stockEOD.getTime()); 
     78            open = stockEOD.getData().getOpen(); 
     79            high = stockEOD.getData().getHigh(); 
     80            low = stockEOD.getData().getLow(); 
     81            close = stockEOD.getData().getClose(); 
     82            volume = stockEOD.getData().getVolume(); 
     83            adjClose = stockEOD.getData().getAdjClose(); 
    8484        } 
    8585 
    … …  
    9898        } 
    9999    }; 
     100 
    100101    private static final Logger logger = getClassLogger(); 
    101102    private static final Charset CHARSET = Charset.forName("windows-1252"); 
    … …  
    107108    private static CellProcessor[] newCellProcessor() { 
    108109        return new CellProcessor[]{ 
    109                 new StrMinMax(1, 100), // timestamp 
    110                 new ParseDouble(), // open 
    111                 new ParseDouble(), // high 
    112                 new ParseDouble(), // low 
    113                 new ParseDouble(), // close 
    114                 new ParseDouble(), // volume 
    115                 new ParseDouble() // adjClose 
    116             }; 
     110            new StrMinMax(1, 100), // timestamp 
     111            new ParseDouble(), // open 
     112            new ParseDouble(), // high 
     113            new ParseDouble(), // low 
     114            new ParseDouble(), // close 
     115            new ParseDouble(), // volume 
     116            new ParseDouble() // adjClose 
     117        }; 
    117118    } 
    118119 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooEODCsvZipFileWriter.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEODCsvZipFileReader.YahooRow; 
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    28 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.data.type.StockEOD; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import static com.numericalmethod.nmutils.NMUtils.*; 
    3131import com.numericalmethod.nmutils.csvzip.CsvZipFileWriter; 
    … …  
    4949 
    5050    /** 
    51      * Creates a writer to save equity data to a given folder. 
     51     * Creates a writer to save stock data to a given folder. 
    5252     * 
    5353     * @param dir the output folder 
    … …  
    6060     * Writes Yahoo! data cache to a .csv.zip file 
    6161     * 
    62      * @param equity the equity to be saved 
    63      * @param cache  {@link YahooEOD} data cache 
     62     * @param stock the equity to be saved 
     63     * @param cache {@link YahooEOD} data cache 
    6464     * @return the number of rows written to the file 
    6565     * @throws IOException if an error occurs during saving the data into the files 
    6666     */ 
    67     public int save(Equity equity, SequentialCache<EquityEOD> cache) throws IOException { 
     67    public int save(Stock stock, SequentialCache<StockEOD> cache) throws IOException { 
    6868        createFolder(dir); 
    6969 
    70         String fileName = String.format("%s/%s.csv.zip", dir, equity.getSymbol()); 
     70        String fileName = String.format("%s/%s.csv.zip", dir, stock.getSymbol()); 
    7171        CsvZipFileWriter csvzip = new CsvZipFileWriter(fileName, 
    7272                                                       new String[]{"timestamp", "open", "high", "low", "close", "volume", "adjClose"}, 
    … …  
    7777        int nRows = 0; 
    7878        try { 
    79             for (TimedEntry<EquityEOD> entry : cache) { 
     79            for (TimedEntry<StockEOD> entry : cache) { 
    8080                if (entry.getData() != null) { 
    8181                    CsvZipRow row = new YahooRow(entry); 
    … …  
    9393 
    9494    /** 
    95      * Downloads and writes Yahoo! data for an equity to a .csv.zip file. 
     95     * Downloads and writes Yahoo! data for an stock to a .csv.zip file. 
    9696     * 
    9797     * @param downloader the web downloader 
    … …  
    102102     */ 
    103103    public int saveFromWeb(YahooEODWebDownloader downloader, DateTime begin, DateTime end) throws IOException { 
    104         return save(downloader.getEquity(), downloader.getCache(begin, end)); 
     104        return save(downloader.getStock(), downloader.getCache(begin, end)); 
    105105    } 
    106106 
    107107    /** 
    108      * Downloads and writes all available Yahoo! data for an equity to a .csv.zip file. 
     108     * Downloads and writes all available Yahoo! data for an stock to a .csv.zip file. 
    109109     * 
    110      * @param equity the equity to be saved 
     110     * @param stock the stock to be saved 
    111111     * @return the number of rows written to the file 
    112112     * @throws IOException if an error occurs during downloading and saving the data into the files 
    113113     */ 
    114     public int saveAllFromWeb(Equity equity) throws IOException { 
    115         return saveFromWeb(new YahooEODWebDownloader(equity), 
    116                            JodaTimeUtils.getDate(1900, 1, 1, equity.getExchange().timeZone),//before the start date in Yahoo 
     114    public int saveAllFromWeb(Stock stock) throws IOException { 
     115        return saveFromWeb(new YahooEODWebDownloader(stock), 
     116                           JodaTimeUtils.getDate(1900, 1, 1, stock.getExchange().timeZone),//before the start date in Yahoo 
    117117                           new DateTime()); //today 
    118118    } 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooEODWebDownloader.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.cache.SequentialCache; 
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    28 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.data.type.StockEOD; 
    3029import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3131import com.numericalmethod.nmutils.io.WebUtils; 
    3232import com.numericalmethod.nmutils.iterator.AbstractReadOnlyIterator; 
    3333import com.numericalmethod.nmutils.iterator.FilterIterator; 
    3434import com.numericalmethod.nmutils.logic.Predicate; 
    35 import java.util.Iterator; 
    36 import java.util.List; 
    37 import java.util.ListIterator; 
     35import java.util.*; 
    3836import org.joda.time.DateTime; 
    3937 
    4038/** 
    41  * Downloads equity data from Yahoo! Finance. 
     39 * Downloads stock data from Yahoo! Finance. 
    4240 * 
    4341 * @author Simon Lui 
    4442 */ 
    45 public class YahooEODWebDownloader implements CacheFactory<EquityEOD> { 
     43public class YahooEODWebDownloader implements CacheFactory<StockEOD> { 
    4644 
    47     private final Equity equity; 
     45    private final Stock stock; 
    4846    private final Exchange exchange; 
    4947 
    5048    /** 
    51      * Creates a downloader for a given equity whose data will be downloaded. 
     49     * Creates a downloader for a given stock whose data will be downloaded. 
    5250     * 
    53      * @param equity the equity 
     51     * @param stock the stock 
    5452     */ 
    55     public YahooEODWebDownloader(Equity equity) { 
    56         this.equity = equity; 
    57         this.exchange = equity.getExchange(); 
     53    public YahooEODWebDownloader(Stock stock) { 
     54        this.stock = stock; 
     55        this.exchange = stock.getExchange(); 
    5856    } 
    5957 
    60     public Equity getEquity() { 
    61         return equity; 
     58    public Stock getStock() { 
     59        return stock; 
    6260    } 
    6361 
    6462    @Override 
    65     public SequentialCache<EquityEOD> getCache(final DateTime begin, final DateTime end) { 
     63    public SequentialCache<StockEOD> getCache(final DateTime begin, final DateTime end) { 
    6664        // URL 
    6765        String inputURL = String.format("http://ichart.finance.yahoo.com/table.csv?s=%s&d=%d&e=%d&f=%d&g=d&a=%d&b=%d&c=%d&ignore=.csv", 
    68                                         getEquity().getSymbol(), 
     66                                        getStock().getSymbol(), 
    6967                                        end.getMonthOfYear() - 1, 
    7068                                        end.getDayOfMonth(), 
    … …  
    8583        } 
    8684 
    87         return new SequentialCache<EquityEOD>() { 
     85        return new SequentialCache<StockEOD>() { 
    8886            /** 
    8987             * Gets the Yahoo! data entry in ascending order of timestamps. 
    … …  
    9290             */ 
    9391            @Override 
    94             public Iterator<TimedEntry<EquityEOD>> iterator() { 
    95                 return new FilterIterator<TimedEntry<EquityEOD>>( 
    96                     new AbstractReadOnlyIterator<TimedEntry<EquityEOD>>() { 
     92            public Iterator<TimedEntry<StockEOD>> iterator() { 
     93                return new FilterIterator<TimedEntry<StockEOD>>( 
     94                    new AbstractReadOnlyIterator<TimedEntry<StockEOD>>() { 
    9795                        private final ListIterator<String> it = lines.listIterator(lines.size()); 
    9896 
    … …  
    103101 
    104102                        @Override 
    105                         public TimedEntry<EquityEOD> next() { 
     103                        public TimedEntry<StockEOD> next() { 
    106104                            String[] line = it.previous().split(","); 
    107                             TimedEntry<EquityEOD> entry = 
    108                                 line[0].matches("(?i).*Date|Open|High|Low|Close|Volume|Adj.*") 
    109                                 ? null 
    110                                 : parseYahooLine(line); 
     105                            TimedEntry<StockEOD> entry = 
     106                            line[0].matches("(?i).*Date|Open|High|Low|Close|Volume|Adj.*") 
     107                            ? null 
     108                            : parseYahooLine(line); 
    111109                            return entry; 
    112110                        } 
    113111                    }, 
    114                     new Predicate<TimedEntry<EquityEOD>>() { 
     112                    new Predicate<TimedEntry<StockEOD>>() { 
    115113                        @Override 
    116                         public boolean evaluate(TimedEntry<EquityEOD> entry) { 
     114                        public boolean evaluate(TimedEntry<StockEOD> entry) { 
    117115                            return entry != null; // filter null entry 
    118116                        } 
    … …  
    123121 
    124122    /** 
    125      * Constructs {@code TimedEntry<EquityEOD>} from Yahoo! string array. 
     123     * Constructs {@code TimedEntry<StockEOD>} from Yahoo! string array. 
    126124     * 
    127125     * @param line 
    128126     * @return 
    129127     */ 
    130     private TimedEntry<EquityEOD> parseYahooLine(String[] line) { 
     128    private TimedEntry<StockEOD> parseYahooLine(String[] line) { 
    131129        String[] timeParts = line[0].split("-"); 
    132130        DateTime date = new DateTime( 
    … …  
    140138            exchange.timeZone); 
    141139 
    142         TimedEntry<EquityEOD> entry = new TimedEntry<EquityEOD>( 
     140        TimedEntry<StockEOD> entry = new TimedEntry<StockEOD>( 
    143141            date, 
    144             new EquityEOD( 
     142            new StockEOD( 
    145143            Double.parseDouble(line[1]),//open 
    146144            Double.parseDouble(line[2]),//high 
    … …  
    149147            Double.parseDouble(line[5]),//volume 
    150148            Double.parseDouble(line[6])//adjClose 
    151             )); 
     149        )); 
    152150 
    153151        return entry; 

  • core/src/main/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooProductUtils.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.historicaldata.yahoo.api.YahooPropertyLoader; 
    2727import com.numericalmethod.algoquant.execution.product.Product; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3030import java.util.ArrayList; 
    … …  
    6161            products.add(new Product() { 
    6262                { 
    63                     add(new Equity(symbol, exchange)); 
     63                    add(new Stock(symbol, exchange)); 
    6464                } 
    6565 

  • core/src/main/java/com/numericalmethod/algoquant/data/type/StockEOD.java

    r1484 r1495  
    2929 * @author Haksun Li 
    3030 */ 
    31 public class EquityEOD extends OHLC implements Subscribable { 
     31public class StockEOD extends OHLC implements Subscribable { 
    3232 
    3333    private final double volume; 
    3434    private final double adjClose; 
    3535 
    36     public EquityEOD(double open, double high, double low, double close, double volume, 
     36    public StockEOD(double open, double high, double low, double close, double volume, 
    3737        double adjClose) { 
    3838        super(open, high, low, close); 

  • core/src/main/java/com/numericalmethod/algoquant/data/type/portfolio/PortfolioGenerator.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.type.portfolio; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import java.util.Set; 
    2727 
    … …  
    4040     * @return the generated portfolio 
    4141     */ 
    42     public Portfolio<Equity> newPortfolio(Set<Equity> equities); 
     42    public Portfolio<Stock> newPortfolio(Set<Stock> equities); 
    4343} 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/ProductUtils.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.execution.product; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    2625import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    27 import java.util.ArrayList; 
    28 import java.util.Currency; 
    29 import java.util.List; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
     27import java.util.*; 
    3028 
    3129/** 
    … …  
    8078 
    8179    /** 
    82      * Creates an equity product with its symbol, trading exchange, and denomination currency. 
     80     * Creates an stock product with its symbol, trading exchange, and denomination currency. 
    8381     * 
    8482     * @param symbol   the symbol of the product 
    … …  
    8785     * @return the product 
    8886     */ 
    89     public static Product newEquityProduct( 
    90         final String symbol, 
    91         final Exchange exchange, 
    92         final Currency currency) { 
     87    public static Product newStockProduct(final String symbol, 
     88                                          final Exchange exchange, 
     89                                          final Currency currency) { 
    9390        return new Product() { 
    9491            { 
    95                 add(new Equity(symbol, exchange)); 
     92                add(new Stock(symbol, exchange)); 
    9693            } 
    9794 
    … …  
    117114     * @return the list of created products 
    118115     */ 
    119     public static List<Product> newEquityProductList( 
    120         String[] symbols, 
    121         Exchange exchange, 
    122         Currency currency) { 
     116    public static List<Product> newStockProductList(String[] symbols, 
     117                                                    Exchange exchange, 
     118                                                    Currency currency) { 
    123119        List<Product> products = new ArrayList<Product>(symbols.length); 
    124120 
    125121        for (String symbol : symbols) { 
    126             products.add(ProductUtils.newEquityProduct(symbol, exchange, currency)); 
     122            products.add(ProductUtils.newStockProduct(symbol, exchange, currency)); 
    127123        } 
    128124 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/Stock.java

    r1484 r1495  
    2626 
    2727/** 
    28  * This class represents an equity product. 
     28 * This class represents a stock. 
    2929 * 
    3030 * @author Haksun Li 
    3131 */ 
    32 public class Equity implements ProductProperty { 
     32public class Stock implements ProductProperty, Comparable<Stock> { 
    3333 
    3434    /** 
    … …  
    4141    private final Exchange exchange; 
    4242 
    43     public Equity(String symbol, Exchange exchange) { 
     43    public Stock(String symbol, Exchange exchange) { 
    4444        this.symbol = symbol; 
    4545        this.exchange = exchange; 
    … …  
    5252    public Exchange getExchange() { 
    5353        return exchange; 
     54    } 
     55 
     56    @Override 
     57    public int compareTo(Stock that) { 
     58        return this.getSymbol().compareTo(that.getSymbol()); 
    5459    } 
    5560 
    … …  
    6873            return false; 
    6974        } 
    70         final Equity other = (Equity) obj; 
     75        final Stock other = (Stock) obj; 
    7176        if ((this.getSymbol() == null) ? (other.getSymbol() != null) : !this.symbol.equals(other.symbol)) { 
    7277            return false; 
    … …  
    8590        return hash; 
    8691    } 
     92 
    8793} 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/hkex/HK0005.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.HKDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3434 
    3535    private HK0005() {//singleton 
    36         add(new Equity("0005.HK", Exchange.HKEX)); 
     36        add(new Stock("0005.HK", Exchange.HKEX)); 
    3737    } 
    3838 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/hkex/HKEXProduct.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.HKDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3434 
    3535    public HKEXProduct(String symbol) { 
    36         add(new Equity(symbol, Exchange.HKEX)); 
     36        add(new Stock(symbol, Exchange.HKEX)); 
    3737    } 
    3838 
    3939    @Override 
    4040    public String name() { 
    41         return this.as(Equity.class).getSymbol(); 
     41        return this.as(Stock.class).getSymbol(); 
    4242    } 
    4343} 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/hkex/HSI.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.HKDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3434 
    3535    private HSI() {//singleton 
    36         add(new Equity("^HSI", Exchange.HKEX)); 
     36        add(new Stock("^HSI", Exchange.HKEX)); 
    3737    } 
    3838 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/sgx/SGXProduct.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.SGDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3434 
    3535    public SGXProduct(String symbol) { 
    36         add(new Equity(symbol, Exchange.SGX)); 
     36        add(new Stock(symbol, Exchange.SGX)); 
    3737    } 
    3838 
    3939    @Override 
    4040    public String name() { 
    41         return this.as(Equity.class).getSymbol(); 
     41        return this.as(Stock.class).getSymbol(); 
    4242    } 
    4343} 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/GSPC.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3838 
    3939    private GSPC() {//singleton 
    40         add(new Equity("^GSPC", Exchange.NEW_YORK)); 
     40        add(new Stock("^GSPC", Exchange.NEW_YORK)); 
    4141    } 
    4242 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/SP500.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.execution.product.Product; 
    2727import com.numericalmethod.algoquant.execution.product.ProductUtils; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3030import static com.numericalmethod.algoquant.execution.product.equity.Exchange.*; 
    … …  
    3939/** 
    4040 * This enum contains the 500 components in S&P 500. Information for each stock 
    41  * like symbol, company name, exchange, {@link Equity} instance and 
     41 * like symbol, company name, exchange, {@link Stock} instance and 
    4242 * {@link Product} instance can be obtained from the corresponding enum value. 
    4343 * 
    … …  
    566566 
    567567    public Product getProduct() { 
    568         return ProductUtils.newEquityProduct(symbol, exchange, USD); 
    569     } 
    570  
    571     public Equity getEquity() { 
    572         return new Equity(symbol, exchange); 
     568        return ProductUtils.newStockProduct(symbol, exchange, USD); 
     569    } 
     570 
     571    public Stock getStock() { 
     572        return new Stock(symbol, exchange); 
    573573    } 
    574574 
    … …  
    599599    } 
    600600 
    601     public static List<Equity> getAllEquities() { 
     601    public static List<Stock> getAllEquities() { 
    602602        return getEquities(EnumSet.allOf(SP500.class)); 
    603603    } 
    604604 
    605     public static List<Equity> getEquities(Set<SP500> stocks) { 
    606         List<Equity> equities = new ArrayList<Equity>(stocks.size()); 
     605    public static List<Stock> getEquities(Set<SP500> stocks) { 
     606        List<Stock> equities = new ArrayList<Stock>(stocks.size()); 
    607607        for (SP500 stock : stocks) { 
    608             equities.add(stock.getEquity()); 
     608            equities.add(stock.getStock()); 
    609609        } 
    610610        return equities; 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/VFINX.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3737 
    3838    private VFINX() {//singleton 
    39         add(new Equity("VFINX", Exchange.NEW_YORK)); 
     39        add(new Stock("VFINX", Exchange.NEW_YORK)); 
    4040    } 
    4141 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nasdaq/AAPL.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    4040 
    4141    private AAPL() {//singleton 
    42         add(new Equity("AAPL", Exchange.NASDAQ)); 
     42        add(new Stock("AAPL", Exchange.NASDAQ)); 
    4343    } 
    4444 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nasdaq/GOOG.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3535 
    3636    private GOOG() {//singleton 
    37         add(new Equity("GOOG", Exchange.NASDAQ)); 
     37        add(new Stock("GOOG", Exchange.NASDAQ)); 
    3838    } 
    3939 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nasdaq/IBM.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3535 
    3636    private IBM() {//singleton 
    37         add(new Equity("IBM", Exchange.NASDAQ)); 
     37        add(new Stock("IBM", Exchange.NASDAQ)); 
    3838    } 
    3939 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nasdaq/MSFT.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3535 
    3636    private MSFT() {//singleton 
    37         add(new Equity("MSFT", Exchange.NASDAQ)); 
     37        add(new Stock("MSFT", Exchange.NASDAQ)); 
    3838    } 
    3939 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nasdaq/NASDAQ100.java

    r1455 r1495  
    2828import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    2929import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    30 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     30import com.numericalmethod.algoquant.data.type.StockEOD; 
    3131import com.numericalmethod.algoquant.execution.product.Product; 
    3232import com.numericalmethod.algoquant.execution.product.USDProduct; 
    33 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     33import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3434import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3535import com.numericalmethod.nmutils.iterator.AbstractReadOnlyIterator; 
    … …  
    8787 
    8888                    { 
    89                         add(new Equity(name, Exchange.NASDAQ)); 
     89                        add(new Stock(name, Exchange.NASDAQ)); 
    9090                    } 
    9191 
    … …  
    102102    } 
    103103 
    104     public Map<Product, SequentialCache<EquityEOD>> getDepthCaches(DateTime begin, DateTime end) { 
    105         Map<Product, SequentialCache<EquityEOD>> map = new HashMap<Product, SequentialCache<EquityEOD>>(); 
     104    public Map<Product, SequentialCache<StockEOD>> getDepthCaches(DateTime begin, DateTime end) { 
     105        Map<Product, SequentialCache<StockEOD>> map = new HashMap<Product, SequentialCache<StockEOD>>(); 
    106106 
    107107        for (Iterator<USDProduct> it = iterator(); it.hasNext();) { 
    108108            Product product = it.next(); 
    109             YahooEOD yahoo = new YahooEOD(product.as(Equity.class), "./log", "./log"); 
    110             SequentialCache<EquityEOD> cache = yahoo.getCache(begin, end); 
     109            YahooEOD yahoo = new YahooEOD(product.as(Stock.class), "./log", "./log"); 
     110            SequentialCache<StockEOD> cache = yahoo.getCache(begin, end); 
    111111            map.put(product, cache); 
    112112        } 
    … …  
    116116 
    117117    public Matrix getMatrix(DateTime begin, DateTime end) { 
    118         AbstractCacheTransformer<EquityEOD, Double> transformer = 
    119             new AbstractCacheTransformer<EquityEOD, Double>() { 
     118        AbstractCacheTransformer<StockEOD, Double> transformer = 
     119            new AbstractCacheTransformer<StockEOD, Double>() { 
    120120            @Override 
    121             public TimedEntry<Double> transform(TimedEntry<EquityEOD> entry) { 
     121            public TimedEntry<Double> transform(TimedEntry<StockEOD> entry) { 
    122122                return new TimedEntry<Double>(entry.getTime(), entry.getData().getAdjClose()); 
    123123            } 
    … …  
    125125 
    126126        List<SequentialCache<Double>> list = new ArrayList<SequentialCache<Double>>(); 
    127         Map<Product, SequentialCache<EquityEOD>> map = getDepthCaches(begin, end); 
    128         for (SequentialCache<EquityEOD> cache0 : map.values()) { 
     127        Map<Product, SequentialCache<StockEOD>> map = getDepthCaches(begin, end); 
     128        for (SequentialCache<StockEOD> cache0 : map.values()) { 
    129129            SequentialCache<Double> cache1 = transformer.doProcess(cache0); 
    130130            list.add(cache1); 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nasdaq/ORCL.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3535 
    3636    private ORCL() {//singleton 
    37         add(new Equity("ORCL", Exchange.NASDAQ)); 
     37        add(new Stock("ORCL", Exchange.NASDAQ)); 
    3838    } 
    3939 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nyse/ERO.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3838 
    3939    private ERO() {//singleton 
    40         add(new Equity("ERO", Exchange.NYSE_ARCA)); 
     40        add(new Stock("ERO", Exchange.NYSE_ARCA)); 
    4141    } 
    4242 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nyse/GBB.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3838 
    3939    private GBB() {//singleton 
    40         add(new Equity("GBB", Exchange.NYSE_ARCA)); 
     40        add(new Stock("GBB", Exchange.NYSE_ARCA)); 
    4141    } 
    4242 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nyse/JYN.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    4141 
    4242    private JYN() {//singleton 
    43         add(new Equity("JYN", Exchange.NYSE_ARCA)); 
     43        add(new Stock("JYN", Exchange.NYSE_ARCA)); 
    4444    } 
    4545 

  • core/src/main/java/com/numericalmethod/algoquant/execution/product/equity/usa/nyse/NYSEProduct.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.execution.product.USDProduct; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828 
    … …  
    3434 
    3535    public NYSEProduct(String symbol) { 
    36         add(new Equity(symbol, Exchange.NYSE)); 
     36        add(new Stock(symbol, Exchange.NYSE)); 
    3737    } 
    3838 
    3939    @Override 
    4040    public String name() { 
    41         return this.as(Equity.class).getSymbol(); 
     41        return this.as(Stock.class).getSymbol(); 
    4242    } 
    4343} 

  • core/src/main/java/com/numericalmethod/algoquant/execution/simulator/handler/ChannelMessageHandlerFactories.java

    r1401 r1495  
    2323package com.numericalmethod.algoquant.execution.simulator.handler; 
    2424 
    25 import com.numericalmethod.algoquant.data.type.Depth; 
    26 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    27 import com.numericalmethod.algoquant.data.type.Execution; 
     25import com.numericalmethod.algoquant.data.type.*; 
    2826import com.numericalmethod.algoquant.execution.simulator.subscription.ChannelMessage; 
    2927import com.numericalmethod.algoquant.execution.simulator.subscription.Subscribable; 
    3028import com.numericalmethod.algoquant.execution.simulator.subscription.timer.TimerEvent; 
    31 import com.numericalmethod.algoquant.execution.strategy.handler.DepthHandler; 
    32 import com.numericalmethod.algoquant.execution.strategy.handler.EquityEODHandler; 
    33 import com.numericalmethod.algoquant.execution.strategy.handler.ExecutionHandler; 
    34 import com.numericalmethod.algoquant.execution.strategy.handler.TimerHandler; 
    35 import com.numericalmethod.algoquant.execution.strategy.handler.UpdateHandler; 
     29import com.numericalmethod.algoquant.execution.strategy.handler.*; 
    3630 
    3731/** 
    … …  
    4741     */ 
    4842    DEPTH(Depth.class) { 
    49         @Override 
    50         public ChannelMessageHandler newHandler(UpdateHandler handler) { 
     43            @Override 
     44            public ChannelMessageHandler newHandler(UpdateHandler handler) { 
    5145 
    52             if (handler instanceof DepthHandler) { 
    53                 return new DepthMessageHandler((DepthHandler) handler); 
     46                if (handler instanceof DepthHandler) { 
     47                    return new DepthMessageHandler((DepthHandler) handler); 
     48                } 
     49 
     50                return new NoOpMessageHandler(); 
    5451            } 
    55  
    56             return new NoOpMessageHandler(); 
    57         } 
    58     }, 
     52        }, 
    5953    /** 
    6054     * Factory for {@link ChannelMessageHandler} of {@link Execution}. 
    6155     */ 
    6256    EXECUTION(Execution.class) { 
    63         @Override 
    64         public ChannelMessageHandler newHandler(UpdateHandler handler) { 
     57            @Override 
     58            public ChannelMessageHandler newHandler(UpdateHandler handler) { 
    6559 
    66             if (handler instanceof ExecutionHandler) { 
    67                 return new ExecutionMessageHandler((ExecutionHandler) handler); 
     60                if (handler instanceof ExecutionHandler) { 
     61                    return new ExecutionMessageHandler((ExecutionHandler) handler); 
     62                } 
     63 
     64                return new NoOpMessageHandler(); 
    6865            } 
     66        }, 
     67    /** 
     68     * Factory for {@link ChannelMessageHandler} of {@link StockEOD}. 
     69     */ 
     70    STOCK_EOD(StockEOD.class) { 
     71            @Override 
     72            public ChannelMessageHandler newHandler(UpdateHandler handler) { 
    6973 
    70             return new NoOpMessageHandler(); 
    71         } 
    72     }, 
    73     /** 
    74      * Factory for {@link ChannelMessageHandler} of {@link EquityEOD}. 
    75      */ 
    76     EQUITY_EOD(EquityEOD.class) { 
    77         @Override 
    78         public ChannelMessageHandler newHandler(UpdateHandler handler) { 
     74                if (handler instanceof StockEODHandler) { 
     75                    return new StockEODMessageHandler((StockEODHandler) handler); 
     76                } 
    7977 
    80             if (handler instanceof EquityEODHandler) { 
    81                 return new EquityEODMessageHandler((EquityEODHandler) handler); 
     78                return new NoOpMessageHandler(); 
    8279            } 
    83  
    84             return new NoOpMessageHandler(); 
    85         } 
    86     }, 
     80        }, 
    8781    /** 
    8882     * Factory for {@link ChannelMessageHandler} of {@link TimerEvent}. 
    8983     */ 
    9084    TIMER(TimerEvent.class) { 
    91         @Override 
    92         public ChannelMessageHandler newHandler(UpdateHandler handler) { 
     85            @Override 
     86            public ChannelMessageHandler newHandler(UpdateHandler handler) { 
    9387 
    94             if (handler instanceof TimerHandler) { 
    95                 return new TimerMessageHandler((TimerHandler) handler); 
     88                if (handler instanceof TimerHandler) { 
     89                    return new TimerMessageHandler((TimerHandler) handler); 
     90                } 
     91 
     92                return new NoOpMessageHandler(); 
    9693            } 
    97  
    98             return new NoOpMessageHandler(); 
    99         } 
    100     }; 
     94        }; 
    10195    private final Class<? extends Subscribable> subscriberClass; 
    10296 

  • core/src/main/java/com/numericalmethod/algoquant/execution/simulator/handler/StockEODMessageHandler.java

    r1484 r1495  
    2323package com.numericalmethod.algoquant.execution.simulator.handler; 
    2424 
    25 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     25import com.numericalmethod.algoquant.data.type.StockEOD; 
    2626import com.numericalmethod.algoquant.execution.simulator.subscription.ChannelMessage; 
    27 import com.numericalmethod.algoquant.execution.strategy.handler.EquityEODHandler; 
     27import com.numericalmethod.algoquant.execution.strategy.handler.StockEODHandler; 
    2828 
    2929/** 
    3030 * A implementation of {@link ChannelMessageHandler} which handles a 
    31  * {@link ChannelMessage} using the underlying {@link EquityEODHandler} instance. 
     31 * {@link ChannelMessage} using the underlying {@link StockEODHandler} instance. 
    3232 * 
    3333 * @author Chung Lee 
    3434 */ 
    35 public class EquityEODMessageHandler implements ChannelMessageHandler { 
     35public class StockEODMessageHandler implements ChannelMessageHandler { 
    3636 
    37     private final EquityEODHandler equityEODHandler; 
     37    private final StockEODHandler stockEODHandler; 
    3838 
    39     public EquityEODMessageHandler(EquityEODHandler equityEODHandler) { 
    40         this.equityEODHandler = equityEODHandler; 
     39    public StockEODMessageHandler(StockEODHandler stockEODHandler) { 
     40        this.stockEODHandler = stockEODHandler; 
    4141    } 
    4242 
    4343    @Override 
    4444    public void handleMessage(ChannelMessage msg) { 
    45         equityEODHandler.onEODUpdate( 
     45        stockEODHandler.onEODUpdate( 
    4646            msg.getTime(), 
    47             (EquityEOD) msg.getData(), 
     47            (StockEOD) msg.getData(), 
    4848            msg.getMarketCondition(), 
    4949            msg.getBlotter(), 

  • core/src/main/java/com/numericalmethod/algoquant/execution/strategy/handler/StockEODHandler.java

    r1484 r1495  
    2323package com.numericalmethod.algoquant.execution.strategy.handler; 
    2424 
    25 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     25import com.numericalmethod.algoquant.data.type.StockEOD; 
    2626import com.numericalmethod.algoquant.data.type.MarketCondition; 
    2727import com.numericalmethod.algoquant.execution.component.tradeblotter.TradeBlotter; 
    … …  
    3030 
    3131/** 
    32  * Interface for a strategy to implement for listening to {@link EquityEOD} updates in a simulation. 
     32 * Interface for a strategy to implement for listening to {@link StockEOD} updates in a simulation. 
    3333 * 
    3434 * @author Chung Lee 
    3535 */ 
    36 public interface EquityEODHandler extends UpdateHandler { 
     36public interface StockEODHandler extends UpdateHandler { 
    3737 
    3838    /** 
    … …  
    4747    public void onEODUpdate( 
    4848        DateTime now, 
    49         EquityEOD eod, 
     49        StockEOD eod, 
    5050        MarketCondition mc, 
    5151        TradeBlotter blotter, 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/FactorValueEvaluator.java

    r1366 r1495  
    2525import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    2626import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2828import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    2929import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    30 import java.util.Collection; 
    31 import java.util.List; 
    32 import java.util.Map; 
     30import java.util.*; 
    3331import org.joda.time.DateTime; 
    3432 
    … …  
    5149 
    5250    public FactorValueLookup evaluateForEquities( 
    53         Collection<Equity> equities, 
     51        Collection<Stock> stocks, 
    5452        DateTime time) { 
    55         EquityFactorValues factorValues = new EquityFactorValues(); 
     53        StockFactorValues factorValues = new StockFactorValues(); 
    5654 
    5755        for (Factor factor : factors) { 
    58             Map<Equity, Double> currentFactorResults = newHashMap(); 
    59             for (Equity equity : equities) { 
    60                 double factorValue = factor.getFactorExposure(equity, time, marketSnapshots); 
    61                 currentFactorResults.put(equity, factorValue); 
     56            Map<Stock, Double> currentFactorResults = newHashMap(); 
     57            for (Stock stock : stocks) { 
     58                double factorValue = factor.getFactorExposure(stock, time, marketSnapshots); 
     59                currentFactorResults.put(stock, factorValue); 
    6260            } 
    6361 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/FactorValueLookup.java

    r1492 r1495  
    2323package com.numericalmethod.algoquant.model.factormodel; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    2727 
    … …  
    3333public interface FactorValueLookup { 
    3434 
    35     public double getValue(Equity equity, Factor factor); 
     35    public double getValue(Stock stock, Factor factor); 
    3636} 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/StockFactorValues.java

    r1484 r1495  
    2323package com.numericalmethod.algoquant.model.factormodel; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    2727import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    3333 * @author Johannes Lehmann 
    3434 */ 
    35 public class EquityFactorValues implements FactorValueLookup { 
     35public class StockFactorValues implements FactorValueLookup { 
    3636 
    37     private final Map<Factor, Map<Equity, Double>> map = newHashMap(16); 
     37    private final Map<Factor, Map<Stock, Double>> map = newHashMap(16); 
    3838 
    39     public void put(Factor factor, Equity equity, double value) { 
    40         Map<Equity, Double> equity2Value = map.get(factor); 
    41         if (equity2Value == null) { 
    42             equity2Value = newHashMap(); 
    43             map.put(factor, equity2Value); 
     39    public void put(Factor factor, Stock stock, double value) { 
     40        Map<Stock, Double> stock2Value = map.get(factor); 
     41        if (stock2Value == null) { 
     42            stock2Value = newHashMap(); 
     43            map.put(factor, stock2Value); 
    4444        } 
    45         equity2Value.put(equity, value); 
     45        stock2Value.put(stock, value); 
    4646    } 
    4747 
    48     public void put(Factor factor, Map<Equity, Double> factorValues) { 
     48    public void put(Factor factor, Map<Stock, Double> factorValues) { 
    4949        map.put(factor, factorValues); 
    5050    } 
    5151 
    52     public double get(Factor factor, Equity equity) { 
    53         return map.get(factor).get(equity); 
     52    public double get(Factor factor, Stock stock) { 
     53        return map.get(factor).get(stock); 
    5454    } 
    5555 
    5656    @Override 
    57     public double getValue(Equity equity, Factor factor) { 
    58         return get(factor, equity); 
     57    public double getValue(Stock stock, Factor factor) { 
     58        return get(factor, stock); 
    5959    } 
    6060 
    … …  
    6262    public String toString() { 
    6363        StringBuilder sb = new StringBuilder(); 
    64         for (Map.Entry<Factor, Map<Equity, Double>> entry : map.entrySet()) { 
    65             for (Map.Entry<Equity, Double> entry1 : entry.getValue().entrySet()) { 
    66                 sb.append(String.format("factor: %s -> (equity: %s, value: %f)%n", entry.getKey().getClass().getSimpleName(), entry1.getKey().getSymbol(), entry1.getValue())); 
     64        for (Map.Entry<Factor, Map<Stock, Double>> entry : map.entrySet()) { 
     65            for (Map.Entry<Stock, Double> entry1 : entry.getValue().entrySet()) { 
     66                sb.append(String.format("factor: %s -> (stock: %s, value: %f)%n", entry.getKey().getClass().getSimpleName(), entry1.getKey().getSymbol(), entry1.getValue())); 
    6767            } 
    6868        } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/amp2008/ZeroCostByFactorsPortfolioGenerator.java

    r1492 r1495  
    2828import com.numericalmethod.algoquant.data.type.portfolio.*; 
    2929import com.numericalmethod.algoquant.data.type.portfolio.weighting.ZeroCostWeighting; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3131import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3232import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    4343 * 
    4444 * <ol> 
    45  * <li>Factor exposures (such as book-to-market ratio) are calculated for each equity. 
     45 * <li>Factor exposures (such as book-to-market ratio) are calculated for each stock. 
    4646 * <li>The calculated exposures are standardized in its group, as defined by the given 
    4747 * {@link GroupGranularity}. 
    … …  
    104104        private final RandomAccessCache<MarketSnapshot> marketSnapshotCache; 
    105105        private final Map<String, CompanyInfo> companyInfos; 
    106         private final ZeroCostWeighting<Equity> weighting; 
     106        private final ZeroCostWeighting<Stock> weighting; 
    107107        private final GroupGranularity granularity; 
    108108 
    … …  
    116116         */ 
    117117        public Builder(RandomAccessCache<MarketSnapshot> marketSnapshotCache, 
    118                        Map<String, CompanyInfo> companyInfos, ZeroCostWeighting<Equity> weighting, 
     118                       Map<String, CompanyInfo> companyInfos, ZeroCostWeighting<Stock> weighting, 
    119119                       GroupGranularity granularity) { 
    120120            this.marketSnapshotCache = marketSnapshotCache; 
    … …  
    129129         * 
    130130         * @param factor the factor the portfolio generation is based on 
    131          * @param time   the time at which the factor exposure of each equity is used for the 
     131         * @param time   the time at which the factor exposure of each stock is used for the 
    132132         *               generation 
    133133         * @return the portfolio generator based on the given factor 
    … …  
    140140    private final RandomAccessCache<MarketSnapshot> marketSnapshotCache; 
    141141    private final Map<String, CompanyInfo> companyInfos; 
    142     private final ZeroCostWeighting<Equity> weighting; 
     142    private final ZeroCostWeighting<Stock> weighting; 
    143143    private final GroupGranularity granularity; 
    144144    private final Factor factor; 
    … …  
    146146 
    147147    ZeroCostByFactorsPortfolioGenerator(RandomAccessCache<MarketSnapshot> marketSnapshotCache, 
    148                                         Map<String, CompanyInfo> companyInfos, ZeroCostWeighting<Equity> weighting, 
     148                                        Map<String, CompanyInfo> companyInfos, ZeroCostWeighting<Stock> weighting, 
    149149                                        GroupGranularity granularity, Factor factor, DateTime time) { 
    150150        this.marketSnapshotCache = marketSnapshotCache; 
    … …  
    157157 
    158158    @Override 
    159     public Portfolio<Equity> newPortfolio(Set<Equity> equities) { 
    160         Map<Equity, Double> exposures = getFactorExposures(factor, equities, time); 
    161         Map<Equity, Double> zScores = standardize(exposures); 
    162         Map<Equity, Double> weights = weighting.computeWeights(zScores); 
    163         return PortfolioUtils.normalize(new Portfolio<Equity>(weights)); 
    164     } 
    165  
    166     private Map<Equity, Double> getFactorExposures(Factor factor, Collection<Equity> equities, 
    167                                                    DateTime time) { 
    168         Map<Equity, Double> factorExposures = newHashMap(); 
    169  
    170         for (Equity equity : equities) { 
    171             factorExposures.put(equity, factor.getFactorExposure(equity, time, marketSnapshotCache)); 
     159    public Portfolio<Stock> newPortfolio(Set<Stock> equities) { 
     160        Map<Stock, Double> exposures = getFactorExposures(factor, equities, time); 
     161        Map<Stock, Double> zScores = standardize(exposures); 
     162        Map<Stock, Double> weights = weighting.computeWeights(zScores); 
     163        return PortfolioUtils.normalize(new Portfolio<Stock>(weights)); 
     164    } 
     165 
     166    private Map<Stock, Double> getFactorExposures(Factor factor, Collection<Stock> stocks, 
     167                                                  DateTime time) { 
     168        Map<Stock, Double> factorExposures = newHashMap(); 
     169 
     170        for (Stock stock : stocks) { 
     171            factorExposures.put(stock, factor.getFactorExposure(stock, time, marketSnapshotCache)); 
    172172        } 
    173173 
    … …  
    175175    } 
    176176 
    177     private Map<Equity, Double> standardize(Map<Equity, Double> equityFactorValues) { // TODO: extract z-score analysis 
    178         Map<String, List<Double>> groupValues = getGroupValues(equityFactorValues); 
     177    private Map<Stock, Double> standardize(Map<Stock, Double> stockFactorValues) { // TODO: extract z-score analysis 
     178        Map<String, List<Double>> groupValues = getGroupValues(stockFactorValues); 
    179179 
    180180        Map<String, Double> averagePerGroup = newHashMap(); // group id -> average 
    … …  
    192192        } 
    193193 
    194         return standardizePerGroup(equityFactorValues, averagePerGroup, stDevPerGroup); 
    195     } 
    196  
    197     private Map<String, List<Double>> getGroupValues(Map<Equity, Double> equityFactorValues) { 
    198         Map<String, List<Double>> groupValues = initializeEmptyListPerGroup(equityFactorValues); 
    199         for (Map.Entry<Equity, Double> entry : equityFactorValues.entrySet()) { 
     194        return standardizePerGroup(stockFactorValues, averagePerGroup, stDevPerGroup); 
     195    } 
     196 
     197    private Map<String, List<Double>> getGroupValues(Map<Stock, Double> stockFactorValues) { 
     198        Map<String, List<Double>> groupValues = initializeEmptyListPerGroup(stockFactorValues); 
     199        for (Map.Entry<Stock, Double> entry : stockFactorValues.entrySet()) { 
    200200            String groupId = getGroupId(entry.getKey()); 
    201201            groupValues.get(groupId).add(entry.getValue()); 
    … …  
    206206 
    207207    private Map<String, List<Double>> initializeEmptyListPerGroup( 
    208         Map<Equity, Double> equityFactorValues) { 
     208        Map<Stock, Double> stockFactorValues) { 
    209209        Map<String, List<Double>> groupValues = newHashMap(); 
    210         for (Map.Entry<Equity, Double> entry : equityFactorValues.entrySet()) { 
    211             Equity equity = entry.getKey(); 
    212             String groupId = getGroupId(equity); 
     210        for (Map.Entry<Stock, Double> entry : stockFactorValues.entrySet()) { 
     211            Stock stock = entry.getKey(); 
     212            String groupId = getGroupId(stock); 
    213213            if (!groupValues.containsKey(groupId)) { 
    214214                groupValues.put(groupId, new ArrayList<Double>(10)); 
    … …  
    218218    } 
    219219 
    220     private Map<Equity, Double> standardizePerGroup( 
    221         Map<Equity, Double> equityFactorValues, 
     220    private Map<Stock, Double> standardizePerGroup( 
     221        Map<Stock, Double> stockFactorValues, 
    222222        Map<String, Double> averagePerGroup, 
    223223        Map<String, Double> stDevPerGroup) { 
    224224        // compute z scores for each stock 
    225         Map<Equity, Double> zScores = newHashMap(); 
    226         for (Map.Entry<Equity, Double> equityValue : equityFactorValues.entrySet()) { 
    227             String groupId = getGroupId(equityValue.getKey()); 
     225        Map<Stock, Double> zScores = newHashMap(); 
     226        for (Map.Entry<Stock, Double> stockValue : stockFactorValues.entrySet()) { 
     227            String groupId = getGroupId(stockValue.getKey()); 
    228228 
    229229            // standardize the factor exposure (per group) to make values of equities from different groups can be compared 
    230             double zScore = (equityValue.getValue() - averagePerGroup.get(groupId)) / stDevPerGroup.get(groupId); 
    231  
    232             zScores.put(equityValue.getKey(), zScore); 
     230            double zScore = (stockValue.getValue() - averagePerGroup.get(groupId)) / stDevPerGroup.get(groupId); 
     231 
     232            zScores.put(stockValue.getKey(), zScore); 
    233233        } 
    234234        return zScores; 
    235235    } 
    236236 
    237     private String getGroupId(Equity equity) { 
    238         return granularity.getGroupId(companyInfos.get(equity.getSymbol())); 
     237    private String getGroupId(Stock stock) { 
     238        return granularity.getGroupId(companyInfos.get(stock.getSymbol())); 
    239239    } 
    240240} 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/backtest/AnnualizedSummaryBacktester.java

    r1366 r1495  
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    2828import com.numericalmethod.algoquant.data.type.portfolio.Portfolio; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import com.numericalmethod.algoquant.model.factormodel.backtest.Backtester.IterationBody; 
    3131import static com.numericalmethod.algoquant.model.returns.ReturnCalculators.*; 
    3232import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    33 import java.util.ArrayList; 
    34 import java.util.List; 
    35 import java.util.Map; 
     33import java.util.*; 
    3634import org.joda.time.DateTime; 
    3735 
    … …  
    5452 
    5553    public BacktestResult backtest( 
    56         Portfolio<Equity> portfolio, 
     54        Portfolio<Stock> portfolio, 
    5755        DateTime startDate, 
    5856        DateTime endDate) { 
    … …  
    6967    } 
    7068 
    71     private double getTotalReturns(Map<Equity, Double> portfolioWeights, DateTime startDate, 
    72         DateTime endDate) { 
    73         double initialValue = getTotalPortfolioValueFromEquityValues(portfolioWeights); 
    74         final Map<Equity, Double> currentEquityValues = newHashMap(portfolioWeights); 
     69    private double getTotalReturns(Map<Stock, Double> portfolioWeights, DateTime startDate, 
     70                                   DateTime endDate) { 
     71        double initialValue = getTotalPortfolioValueFromStockValues(portfolioWeights); 
     72        final Map<Stock, Double> currentStockValues = newHashMap(portfolioWeights); 
    7573        backtest.performIteration(startDate, endDate, new IterationBody() { 
    7674            @Override 
    7775            public void step(TimedEntry<MarketSnapshot> previousSnapshot, 
    78                 TimedEntry<MarketSnapshot> currentSnapshot) { 
    79                 BacktestUtils.updateEquityValues(currentEquityValues, previousSnapshot.getData(), currentSnapshot.getData()); 
     76                             TimedEntry<MarketSnapshot> currentSnapshot) { 
     77                BacktestUtils.updateStockValues(currentStockValues, previousSnapshot.getData(), currentSnapshot.getData()); 
    8078            } 
    8179        }); 
    82         double currentValue = BacktestUtils.computeSum(currentEquityValues.values()); 
     80        double currentValue = BacktestUtils.computeSum(currentStockValues.values()); 
    8381        double totalReturn = SIMPLE.computeReturn(initialValue, currentValue); 
    8482        return totalReturn; 
    8583    } 
    8684 
    87     private double getTotalPortfolioValueFromEquityValues(Map<Equity, Double> currentEquityValues) { 
    88         return BacktestUtils.computeSum(currentEquityValues.values()); 
     85    private double getTotalPortfolioValueFromStockValues(Map<Stock, Double> currentStockValues) { 
     86        return BacktestUtils.computeSum(currentStockValues.values()); 
    8987    } 
    9088 
    91     private List<Double> getDailyMarginalReturns(Map<Equity, Double> portfolioWeights, 
    92         DateTime startDate, DateTime endDate) { 
     89    private List<Double> getDailyMarginalReturns(Map<Stock, Double> portfolioWeights, 
     90                                                 DateTime startDate, DateTime endDate) { 
    9391        final List<Double> dailyMarginalReturns = new ArrayList<Double>(); 
    94         final Map<Equity, Double> currentEquityValues = newHashMap(portfolioWeights); 
     92        final Map<Stock, Double> currentStockValues = newHashMap(portfolioWeights); 
    9593 
    9694        backtest.performIteration(startDate, endDate, new IterationBody() { 
    9795            @Override 
    9896            public void step(TimedEntry<MarketSnapshot> previousSnapshot, 
    99                 TimedEntry<MarketSnapshot> currentSnapshot) { 
    100                 double lastPortfolioValue = getTotalPortfolioValueFromEquityValues(currentEquityValues); 
    101                 BacktestUtils.updateEquityValues(currentEquityValues, previousSnapshot.getData(), currentSnapshot.getData()); 
    102                 double currentPortfolioValue = getTotalPortfolioValueFromEquityValues(currentEquityValues); 
     97                             TimedEntry<MarketSnapshot> currentSnapshot) { 
     98                double lastPortfolioValue = getTotalPortfolioValueFromStockValues(currentStockValues); 
     99                BacktestUtils.updateStockValues(currentStockValues, previousSnapshot.getData(), currentSnapshot.getData()); 
     100                double currentPortfolioValue = getTotalPortfolioValueFromStockValues(currentStockValues); 
    103101                double marginalReturn = SIMPLE.computeReturn(lastPortfolioValue, currentPortfolioValue); 
    104102                dailyMarginalReturns.add(marginalReturn); 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/backtest/BacktestUtils.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.model.returns.ReturnCalculators; 
    3030import com.numericalmethod.suanshu.number.DoubleUtils; 
    3131import com.numericalmethod.suanshu.number.doublearray.DoubleArrayMath; 
    32 import java.util.ArrayList; 
    33 import java.util.Collection; 
    34 import java.util.List; 
    35 import java.util.Map; 
     32import java.util.*; 
    3633import org.joda.time.DateTime; 
    3734 
    … …  
    5451    } 
    5552 
    56     public static void updateEquityValues( 
    57         Map<Equity, Double> equityValueAccumulator, 
     53    public static void updateStockValues( 
     54        Map<Stock, Double> stockValueAccumulator, 
    5855        MarketSnapshot oldSnapshot, 
    5956        MarketSnapshot newSnapshot) { 
    60         for (Equity equity : equityValueAccumulator.keySet()) { 
    61             double previousPeriodsPrice = equityValueAccumulator.get(equity); 
    62             double thisPeriodsReturn = getReturnForEquity(oldSnapshot, newSnapshot, equity); 
     57        for (Stock stock : stockValueAccumulator.keySet()) { 
     58            double previousPeriodsPrice = stockValueAccumulator.get(stock); 
     59            double thisPeriodsReturn = getReturnForStock(oldSnapshot, newSnapshot, stock); 
    6360            double currentPrice = previousPeriodsPrice * (1 + thisPeriodsReturn); 
    64             equityValueAccumulator.put(equity, currentPrice); 
     61            stockValueAccumulator.put(stock, currentPrice); 
    6562        } 
    6663    } 
    6764 
    68     private static double getReturnForEquity(MarketSnapshot oldSnapshot, MarketSnapshot newSnapshot, 
    69         Equity equity) { 
    70         double oldPrice = oldSnapshot.getProfile(equity).getPrice(); 
    71         double newPrice = newSnapshot.getProfile(equity).getPrice(); 
     65    private static double getReturnForStock(MarketSnapshot oldSnapshot, MarketSnapshot newSnapshot, 
     66                                            Stock stock) { 
     67        double oldPrice = oldSnapshot.getProfile(stock).getPrice(); 
     68        double newPrice = newSnapshot.getProfile(stock).getPrice(); 
    7269        double returnValue = ReturnCalculators.SIMPLE.computeReturn(oldPrice, newPrice); 
    7370        return returnValue; 
    … …  
    8481            @Override 
    8582            public void step(TimedEntry<MarketSnapshot> previousSnapshot, 
    86                 TimedEntry<MarketSnapshot> currentSnapshot) { 
     83                             TimedEntry<MarketSnapshot> currentSnapshot) { 
    8784                riskFreeReturns.add(getDailyFromAnnualRate(currentSnapshot.getData().getRiskFreeRate() / 100.0)); 
    8885            } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/backtest/MonthlyReturnsBacktester.java

    r1366 r1495  
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    2828import com.numericalmethod.algoquant.data.type.portfolio.Portfolio; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    3131import java.util.Iterator; 
    … …  
    4747    } 
    4848 
    49     public BacktestResult backtest(Portfolio<Equity> portfolio, DateTime startDate, DateTime endDate) { 
     49    public BacktestResult backtest(Portfolio<Stock> portfolio, DateTime startDate, DateTime endDate) { 
    5050        BacktestResult result = new BacktestResult(); 
    5151        result.monthlyMarginalReturns = getMonthlyMarginalReturnsFromDaily(portfolio, startDate, endDate); 
    … …  
    5555    } 
    5656 
    57     private Map<DateTime, Double> getMonthlyMarginalReturnsFromDaily(Portfolio<Equity> portfolio, 
     57    private Map<DateTime, Double> getMonthlyMarginalReturnsFromDaily(Portfolio<Stock> portfolio, 
    5858        DateTime startDate, DateTime endDate) { 
    5959        final Map<DateTime, Double> monthlyReturns = newHashMap(); 
    … …  
    6666 
    6767        while (marketSnaphotsIterator.hasNext()) { 
    68             Map<Equity, Double> monthlyValueAccumulator = newHashMap(portfolio.getWeights()); 
     68            Map<Stock, Double> monthlyValueAccumulator = newHashMap(portfolio.getWeights()); 
    6969            int currentMonth = currentSnapshot.getTime().getMonthOfYear(); 
    7070            while (marketSnaphotsIterator.hasNext()) { 
    71                 BacktestUtils.updateEquityValues(monthlyValueAccumulator, previousSnapshot.getData(), currentSnapshot.getData()); 
     71                BacktestUtils.updateStockValues(monthlyValueAccumulator, previousSnapshot.getData(), currentSnapshot.getData()); 
    7272                previousSnapshot = currentSnapshot; 
    7373                currentSnapshot = marketSnaphotsIterator.next(); 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/factor/Beta.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    26 import com.numericalmethod.algoquant.data.cache.SequentialCache; 
    2726import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    2827import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    2928import com.numericalmethod.algoquant.data.equity.snapshot.MonthlyDataFromMarketSnapshots; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3130import com.numericalmethod.algoquant.model.factormodel.capm.CAPM; 
    3231import com.numericalmethod.algoquant.model.factormodel.capm.CAPMFromMonthlyData; 
    … …  
    5554 
    5655    @Override 
    57     public double getFactorExposure(Equity equity, DateTime time, 
    58         RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    59         MonthlyDataFromMarketSnapshots monthlyData = getMonthlyData(marketSnapshotCache, equity); 
     56    public double getFactorExposure(Stock stock, DateTime time, 
     57                                    RandomAccessCache<MarketSnapshot> snapshots) { 
     58        MonthlyDataFromMarketSnapshots monthlyData = new MonthlyDataFromMarketSnapshots(snapshots, stock); 
    6059 
    6160        CAPM capm = new CAPMFromMonthlyData().regressFromMonthlyPrices( 
    … …  
    6665            time.minusMonths(periodInMonths)); 
    6766        return capm.beta(); 
    68     } 
    69  
    70     private static MonthlyDataFromMarketSnapshots getMonthlyData( 
    71         SequentialCache<MarketSnapshot> marketSnapshotCache, 
    72         Equity equity) { 
    73         return new MonthlyDataFromMarketSnapshots(marketSnapshotCache, equity); 
    7467    } 
    7568 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/factor/Factor.java

    r1492 r1495  
    2626import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    2727import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import java.util.Set; 
    3030import org.joda.time.DateTime; 
    … …  
    3939 
    4040    /** 
    41      * Computes the exposure of this factor for a given equity at a given date/time. 
     41     * Computes the exposure of this factor for a given stock at a given date/time. 
    4242     * <p/> 
    4343     * Note: the caller has to ensure that data ranging from {@link #getFirstRequiredDate} to time 
    … …  
    4545     * the data. As a consequence, returns should always be calculated from the change in prices. 
    4646     * 
    47      * @param equity              the equity for which the factor is to be calculated 
     47     * @param stock               the stock for which the factor is to be calculated 
    4848     * @param time                the time for which the factor is to be calculated 
    4949     * @param marketSnapshotCache the {@link RandomAccessCache} of {@link MarketSnapshot}s from 
    … …  
    5252     */ 
    5353    // TODO: should take in a lookup interface instead of cache of marketsnapshot (DIP) 
    54     public double getFactorExposure(Equity equity, DateTime time, 
     54    public double getFactorExposure(Stock stock, DateTime time, 
    5555                                    RandomAccessCache<MarketSnapshot> marketSnapshotCache); 
    5656 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/factor/Intercept.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    2727import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    3030import java.util.Collections; 
    … …  
    4141 
    4242    @Override 
    43     public double getFactorExposure(Equity equity, DateTime time, 
     43    public double getFactorExposure(Stock equity, DateTime time, 
    4444        RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    4545        return 1.0; 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/factor/LogMarketCap.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.equity.measure.MarketCap; 
    2727import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import org.joda.time.DateTime; 
    3030 
    … …  
    4141 
    4242    @Override 
    43     public double getFactorExposure(Equity equity, DateTime time, 
    44         RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    45         double mCap = super.getFactorExposure(equity, time, marketSnapshotCache); // For more readable results 
     43    public double getFactorExposure(Stock stock, DateTime time, 
     44                                    RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     45        double mCap = super.getFactorExposure(stock, time, marketSnapshotCache); // For more readable results 
    4646        return (mCap <= 1.) ? 0. : Math.log(mCap); 
    4747    } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/factor/MeasureFactor.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    2727import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import java.util.Collections; 
    3030import java.util.Set; 
    … …  
    4646 
    4747    @Override 
    48     public double getFactorExposure(Equity equity, DateTime time, 
    49         RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     48    public double getFactorExposure(Stock stock, DateTime time, 
     49                                    RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    5050        MarketSnapshot marketSnapshot = marketSnapshotCache.get(time).getData(); 
    51         return marketSnapshot.getProfile(equity).getMeasureValue(measure); 
     51        return marketSnapshot.getProfile(stock).getMeasureValue(measure); 
    5252    } 
    5353 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/factor/accounting/AccountingFactor.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.equity.CompanyProfile; 
    2727import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3030import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    … …  
    5656 
    5757    @Override 
    58     public double getFactorExposure(Equity equity, DateTime time, 
    59         RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     58    public double getFactorExposure(Stock stock, DateTime time, 
     59                                    RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    6060        DateTime marketDate = time.minus(marketDateOffset); 
    6161        DateTime accountDate = time.minus(accountDateOffset); 
    6262 
    63         CompanyProfile profileAtMarketDate = marketSnapshotCache.get(marketDate).getData().getProfile(equity); 
    64         CompanyProfile profileAtAccountingDate = marketSnapshotCache.get(accountDate).getData().getProfile(equity); 
     63        CompanyProfile profileAtMarketDate = marketSnapshotCache.get(marketDate).getData().getProfile(stock); 
     64        CompanyProfile profileAtAccountingDate = marketSnapshotCache.get(accountDate).getData().getProfile(stock); 
    6565 
    6666        double factorValue = getFactorValue(profileAtMarketDate, profileAtAccountingDate); 
    … …  
    6969 
    7070    public abstract double getFactorValue(CompanyProfile profileAtMarketDate, 
    71         CompanyProfile profileAtAccountingDate); 
     71                                          CompanyProfile profileAtAccountingDate); 
    7272 
    7373    @Override 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/factor/accounting/BookToMarket.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.equity.CompanyProfile; 
    26 import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    27 import com.numericalmethod.algoquant.data.equity.measure.EquityMeasure; 
    28 import com.numericalmethod.algoquant.data.equity.measure.MarketCap; 
    29 import java.util.Arrays; 
    30 import java.util.Collections; 
    31 import java.util.HashSet; 
    32 import java.util.Set; 
     26import com.numericalmethod.algoquant.data.equity.measure.*; 
     27import java.util.*; 
    3328 
    3429/** 
    … …  
    3833 
    3934    private static final MarketCap MCAP = new MarketCap(); 
    40     private static final EquityMeasure EQUITY = new EquityMeasure(); 
    41     private static final Set<CompanyMeasure> MEASURES = Collections.unmodifiableSet(new HashSet<CompanyMeasure>(Arrays.asList(MCAP, EQUITY))); 
     35    private static final StockMeasure STOCK = new StockMeasure(); 
     36    private static final Set<CompanyMeasure> MEASURES = Collections.unmodifiableSet(new HashSet<CompanyMeasure>(Arrays.asList(MCAP, STOCK))); 
    4237 
    4338    @Override 
    … …  
    4641        CompanyProfile profileAtAccountingDate) { 
    4742        double marketCapitalization = profileAtMarketDate.getMeasureValue(MCAP); 
    48         double book = profileAtAccountingDate.getMeasureValue(EQUITY); 
     43        double book = profileAtAccountingDate.getMeasureValue(STOCK); 
    4944        double bm = book / marketCapitalization; 
    5045        return bm; 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/backtest/IndexedPortfoliosAverageReturnsCalculator.java

    r1401 r1495  
    2727import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    2828import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    3131import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    5858     * @return the returns at each time instant 
    5959     */ 
    60     public static SequentialCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> computeAverageReturnsTimeSeries( 
    61         SequentialCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries, 
     60    public static SequentialCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> computeAverageReturnsTimeSeries( 
     61        SequentialCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries, 
    6262        List<TimedEntry<PortfoliosSnapshot>> portfoliosSnapshots, 
    6363        DateTime endDate) { 
    6464 
    65         BufferCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> avgReturnsSeries = 
    66             new BufferCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>>(); 
     65        BufferCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> avgReturnsSeries = 
     66            new BufferCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>>(); 
    6767 
    68         Iterator<TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>>> portfoliosIterator = portfoliosTimeSeries.iterator(); 
    69         TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>> lastPortfolios = portfoliosIterator.next(); 
     68        Iterator<TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>>> portfoliosIterator = portfoliosTimeSeries.iterator(); 
     69        TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>> lastPortfolios = portfoliosIterator.next(); 
    7070 
    7171        while (portfoliosIterator.hasNext()) { 
    72             TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>> currPortfolios = portfoliosIterator.next(); 
     72            TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>> currPortfolios = portfoliosIterator.next(); 
    7373            DateTime startTime = lastPortfolios.getTime(); 
    7474            DateTime endTime = currPortfolios.getTime(); 
    75             List<IndexedPortfolio<FactorRanks, Equity>> portfolios = lastPortfolios.getData(); // compute the return for the last portfolio 
     75            List<IndexedPortfolio<FactorRanks, Stock>> portfolios = lastPortfolios.getData(); // compute the return for the last portfolio 
    7676 
    7777            avgReturnsSeries.add(startTime, getAverageReturnsPerPortfolio(portfolios, portfoliosSnapshots, startTime, endTime)); 
    … …  
    8080        } 
    8181        DateTime startTime = lastPortfolios.getTime(); 
    82         List<IndexedPortfolio<FactorRanks, Equity>> portfolios = lastPortfolios.getData(); // compute the return for the last portfolio 
     82        List<IndexedPortfolio<FactorRanks, Stock>> portfolios = lastPortfolios.getData(); // compute the return for the last portfolio 
    8383 
    8484        avgReturnsSeries.add(startTime, getAverageReturnsPerPortfolio(portfolios, portfoliosSnapshots, startTime, endDate)); 
    … …  
    9494     *         startTime and endTime 
    9595     */ 
    96     private static Map<IndexedPortfolio<FactorRanks, Equity>, Double> getAverageReturnsPerPortfolio( 
    97         List<IndexedPortfolio<FactorRanks, Equity>> portfolios, 
     96    private static Map<IndexedPortfolio<FactorRanks, Stock>, Double> getAverageReturnsPerPortfolio( 
     97        List<IndexedPortfolio<FactorRanks, Stock>> portfolios, 
    9898        List<TimedEntry<PortfoliosSnapshot>> portfoliosStates, 
    9999        DateTime startTime, 
    100100        DateTime endTime) { 
    101         Map<IndexedPortfolio<FactorRanks, Equity>, Double> averageReturns = newHashMap(); 
    102         for (IndexedPortfolio<FactorRanks, Equity> portfolio : portfolios) { 
     101        Map<IndexedPortfolio<FactorRanks, Stock>, Double> averageReturns = newHashMap(); 
     102        for (IndexedPortfolio<FactorRanks, Stock> portfolio : portfolios) { 
    103103            double[] returns = getMarginalReturnsForPortfolioIndices( 
    104104                portfolio.getIndex(), 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/backtest/PerPortfolioIndicesResults.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    2727import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    3030import java.util.List; 
    … …  
    4242public class PerPortfolioIndicesResults { 
    4343 
    44     private final SequentialCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> resultsTimeSeries; 
     44    private final SequentialCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> resultsTimeSeries; 
    4545    private final List<Integer> measureDimensions; 
    4646 
    4747    public PerPortfolioIndicesResults( 
    48         SequentialCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> returnsTimeSeries, 
     48        SequentialCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> returnsTimeSeries, 
    4949        List<Integer> measureDimensions) { 
    5050        this.resultsTimeSeries = returnsTimeSeries; 
    … …  
    5858        int[][] twoDimensionalCount = new int[dimensionA][dimensionB]; 
    5959 
    60         for (TimedEntry<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> timedResultsTable : resultsTimeSeries) { 
    61             for (Entry<IndexedPortfolio<FactorRanks, Equity>, Double> result : timedResultsTable.getData().entrySet()) { 
     60        for (TimedEntry<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> timedResultsTable : resultsTimeSeries) { 
     61            for (Entry<IndexedPortfolio<FactorRanks, Stock>, Double> result : timedResultsTable.getData().entrySet()) { 
    6262                int resultMeasureA = result.getKey().getIndex().getRanks()[measureAIndex]; 
    6363                int resultMeasureB = result.getKey().getIndex().getRanks()[measureBIndex]; 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/backtest/PortfolioSnapshotsCalculator.java

    r1401 r1495  
    2323package com.numericalmethod.algoquant.model.factormodel.famafrench1992.backtest; 
    2424 
    25 import com.numericalmethod.algoquant.data.cache.CacheUtils; 
    26 import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    27 import com.numericalmethod.algoquant.data.cache.SequentialCache; 
     25import com.numericalmethod.algoquant.data.cache.*; 
    2826import com.numericalmethod.algoquant.data.cache.processor.sampler.EquiTimeSampler; 
    2927import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    3028import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    3129import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3331import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    3432import com.numericalmethod.algoquant.model.returns.ReturnCalculators; 
    3533import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    36 import java.util.ArrayList; 
    37 import java.util.Iterator; 
    38 import java.util.List; 
    39 import java.util.Map; 
     34import java.util.*; 
    4035import org.joda.time.DateTime; 
    4136import org.joda.time.Period; 
    … …  
    7469    // TODO: refactor this!! why need the last date?! 
    7570    public List<TimedEntry<PortfoliosSnapshot>> computePortfolioStates( 
    76         SequentialCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosCache, 
     71        SequentialCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosCache, 
    7772        DateTime endDate) { 
    7873        List<TimedEntry<PortfoliosSnapshot>> allPortfoliosSnapshots = 
    … …  
    8378            new EquiTimeSampler<MarketSnapshot>(totalStartTime, period).doProcess(marketSnapshots); 
    8479 
    85  
    86  
    87  
    88         Iterator<TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>>> timedPortfoliosIterator = portfoliosCache.iterator(); 
    89         TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>> lastPortfolios = null; // 1st set of portfolios 
    90         TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>> currPortfolios = timedPortfoliosIterator.next(); 
     80        Iterator<TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>>> timedPortfoliosIterator = portfoliosCache.iterator(); 
     81        TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>> lastPortfolios = null; // 1st set of portfolios 
     82        TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>> currPortfolios = timedPortfoliosIterator.next(); 
    9183        while (timedPortfoliosIterator.hasNext()) { 
    9284            lastPortfolios = currPortfolios; 
    … …  
    9890            List<TimedEntry<PortfoliosSnapshot>> portfoliosSnapshots = 
    9991                generatePortfolioSnapshotsTimeSeries( 
    100                 lastPortfolios.getData(), 
    101                 marketSnapshotPerPeriod, 
    102                 startTime, 
    103                 endTime); 
     92                    lastPortfolios.getData(), 
     93                    marketSnapshotPerPeriod, 
     94                    startTime, 
     95                    endTime); 
    10496            allPortfoliosSnapshots.addAll(portfoliosSnapshots); 
    10597        } 
    10698        List<TimedEntry<PortfoliosSnapshot>> portfoliosSnapshots = // for the last period 
    10799            generatePortfolioSnapshotsTimeSeries( 
    108             currPortfolios.getData(), 
    109             marketSnapshotPerPeriod, 
    110             currPortfolios.getTime(), 
    111             endDate); 
     100                currPortfolios.getData(), 
     101                marketSnapshotPerPeriod, 
     102                currPortfolios.getTime(), 
     103                endDate); 
    112104        allPortfoliosSnapshots.addAll(portfoliosSnapshots); 
    113105        return allPortfoliosSnapshots; 
    … …  
    132124     */ 
    133125    private List<TimedEntry<PortfoliosSnapshot>> generatePortfolioSnapshotsTimeSeries( 
    134         List<IndexedPortfolio<FactorRanks, Equity>> portfolios, 
     126        List<IndexedPortfolio<FactorRanks, Stock>> portfolios, 
    135127        SequentialCache<MarketSnapshot> marketSnapshotPerPeriod, 
    136128        DateTime calculationStartDate, 
    … …  
    154146                    portfolioSnapshots.add( 
    155147                        new TimedEntry<PortfoliosSnapshot>( 
    156                         currentTime, 
    157                         new PortfoliosSnapshot(snapshot, returns, portfolios))); 
     148                            currentTime, 
     149                            new PortfoliosSnapshot(snapshot, returns, portfolios))); 
    158150                } 
    159151 
    … …  
    171163 
    172164    private Map<FactorRanks, Double> getPortfolioReturns( 
    173         List<IndexedPortfolio<FactorRanks, Equity>> portfolios, 
     165        List<IndexedPortfolio<FactorRanks, Stock>> portfolios, 
    174166        MarketSnapshot periodStartSnapshot, 
    175167        MarketSnapshot periodEndSnapshot) { 
    176168        Map<FactorRanks, Double> portfolioReturns = newHashMap(); 
    177169 
    178         for (IndexedPortfolio<FactorRanks, Equity> portfolio : portfolios) { 
     170        for (IndexedPortfolio<FactorRanks, Stock> portfolio : portfolios) { 
    179171            double price = 0.; 
    180             for (Map.Entry<Equity, Double> equityWeight : portfolio.getPortfolio().getWeights().entrySet()) { 
    181                 Equity equity = equityWeight.getKey(); 
    182                 double equityPriceStart = periodStartSnapshot.getProfile(equity).getPrice(); 
    183                 double equityPriceEnd = periodEndSnapshot.getProfile(equity).getPrice(); 
    184                 double returns = ReturnCalculators.SIMPLE.computeReturn(equityPriceStart, equityPriceEnd); 
    185                 double returnsContribution = equityWeight.getValue() * returns; 
     172            for (Map.Entry<Stock, Double> stockWeight : portfolio.getPortfolio().getWeights().entrySet()) { 
     173                Stock stock = stockWeight.getKey(); 
     174                double stockPriceStart = periodStartSnapshot.getProfile(stock).getPrice(); 
     175                double stockPriceEnd = periodEndSnapshot.getProfile(stock).getPrice(); 
     176                double returns = ReturnCalculators.SIMPLE.computeReturn(stockPriceStart, stockPriceEnd); 
     177                double returnsContribution = stockWeight.getValue() * returns; 
    186178                price += returnsContribution; 
    187179            } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/backtest/PortfoliosSnapshot.java

    r1366 r1495  
    2525import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    2626import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2828import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    2929import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    4242 
    4343    private final MarketSnapshot marketSnapshot; 
    44     private final List<IndexedPortfolio<FactorRanks, Equity>> portfolios; 
     44    private final List<IndexedPortfolio<FactorRanks, Stock>> portfolios; 
    4545    private final Map<FactorRanks, Double> portfolioReturns; // for previous period // TODO: why store the last period return but not this period??!!! 
    46     private final Map<FactorRanks, IndexedPortfolio<FactorRanks, Equity>> portfolioMap = newHashMap(); 
     46    private final Map<FactorRanks, IndexedPortfolio<FactorRanks, Stock>> portfolioMap = newHashMap(); 
    4747 
    4848    public PortfoliosSnapshot( 
    4949        MarketSnapshot marketSnapshot, 
    5050        Map<FactorRanks, Double> portfolioReturns, 
    51         List<IndexedPortfolio<FactorRanks, Equity>> portfolios) { 
     51        List<IndexedPortfolio<FactorRanks, Stock>> portfolios) { 
    5252        this.marketSnapshot = marketSnapshot; 
    5353        this.portfolios = portfolios; 
    5454        this.portfolioReturns = portfolioReturns; 
    5555 
    56         for (IndexedPortfolio<FactorRanks, Equity> portfolio : portfolios) { 
     56        for (IndexedPortfolio<FactorRanks, Stock> portfolio : portfolios) { 
    5757            portfolioMap.put(portfolio.getIndex(), portfolio); 
    5858        } 
    … …  
    7171    } 
    7272 
    73     public List<IndexedPortfolio<FactorRanks, Equity>> getPortfolios() { 
     73    public List<IndexedPortfolio<FactorRanks, Stock>> getPortfolios() { 
    7474        return Collections.unmodifiableList(portfolios); 
    7575    } 
    7676 
    77     public IndexedPortfolio<FactorRanks, Equity> getIndexedPortfolio(FactorRanks index) { 
     77    public IndexedPortfolio<FactorRanks, Stock> getIndexedPortfolio(FactorRanks index) { 
    7878        return portfolioMap.get(index); 
    7979    } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/portfolio/FactorRanking.java

    r1420 r1495  
    2525import com.numericalmethod.algoquant.data.equity.bucketing.Bucket; 
    2626import com.numericalmethod.algoquant.data.equity.bucketing.Bucketing; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2828import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
    2929import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    … …  
    132132     */ 
    133133    public FactorRanking( 
    134             List<Factor> factors, 
    135             Map<Factor, Integer> factor2nBuckets, 
    136             FactorValueLookup factorValueLookup, 
    137             BucketSizeAllocation allocation) { 
     134        List<Factor> factors, 
     135        Map<Factor, Integer> factor2nBuckets, 
     136        FactorValueLookup factorValueLookup, 
     137        BucketSizeAllocation allocation) { 
    138138        this.factors = factors; 
    139139        this.factor2nBuckets = factor2nBuckets; 
    … …  
    143143 
    144144    @Override 
    145     public Map<FactorRanks, Bucket<FactorRanks>> sort(Set<Equity> equities) { 
    146         Map<Equity, List<Integer>> equity2Ranks = computeEquityRanks(equities); 
    147  
    148         Map<FactorRanks, Set<Equity>> ranks2Equities = assignEquitiesToSets(equities, equity2Ranks); 
     145    public Map<FactorRanks, Bucket<FactorRanks>> sort(Set<Stock> equities) { 
     146        Map<Stock, List<Integer>> stock2Ranks = computeStockRanks(equities); 
     147 
     148        Map<FactorRanks, Set<Stock>> ranks2Equities = assignEquitiesToSets(equities, stock2Ranks); 
    149149 
    150150        Map<FactorRanks, Bucket<FactorRanks>> buckets = newHashMap(); 
    151         for (Map.Entry<FactorRanks, Set<Equity>> entry : ranks2Equities.entrySet()) { 
     151        for (Map.Entry<FactorRanks, Set<Stock>> entry : ranks2Equities.entrySet()) { 
    152152            buckets.put(entry.getKey(), new Bucket<FactorRanks>(entry.getKey(), entry.getValue())); 
    153153        } 
    … …  
    156156    } 
    157157 
    158     private Map<Equity, List<Integer>> computeEquityRanks(Set<Equity> equities) { 
    159         List<Equity> equityList = new ArrayList<Equity>(equities); 
    160         Map<Equity, List<Integer>> equity2Ranks = newHashMap(); 
    161         for (Equity equity : equities) { // initialize ranks list 
    162             equity2Ranks.put(equity, new ArrayList<Integer>(factors.size())); 
     158    private Map<Stock, List<Integer>> computeStockRanks(Set<Stock> stocks) { 
     159        List<Stock> stockList = new ArrayList<Stock>(stocks); 
     160        Map<Stock, List<Integer>> stock2Ranks = newHashMap(); 
     161        for (Stock stock : stocks) { // initialize ranks list 
     162            stock2Ranks.put(stock, new ArrayList<Integer>(factors.size())); 
    163163        } 
    164164 
    … …  
    166166            final Factor factor = factor1; 
    167167            // sort equities for each factor 
    168             Collections.sort(equityList, new Comparator<Equity>() { 
     168            Collections.sort(stockList, new Comparator<Stock>() { 
    169169                @Override 
    170                 public int compare(Equity o1, Equity o2) { 
     170                public int compare(Stock o1, Stock o2) { 
    171171                    return Double.compare( 
    172                             factorValueLookup.getValue(o1, factor), 
    173                             factorValueLookup.getValue(o2, factor)); 
     172                        factorValueLookup.getValue(o1, factor), 
     173                        factorValueLookup.getValue(o2, factor)); 
    174174                } 
    175175            }); 
    176176 
    177             int[] bucketSizes = allocation.computeBucketSizes(equityList.size(), factor2nBuckets.get(factor)); 
    178  
    179             Iterator<Equity> equityIterator = equityList.iterator(); 
     177            int[] bucketSizes = allocation.computeBucketSizes(stockList.size(), factor2nBuckets.get(factor)); 
     178 
     179            Iterator<Stock> stockIterator = stockList.iterator(); 
    180180            for (int bucketRank = 1; bucketRank <= bucketSizes.length; ++bucketRank) { // bucket index starts from 1 
    181181                int bucketSize = bucketSizes[bucketRank - 1]; 
    182182                for (int i = 0; i < bucketSize; ++i) { 
    183                     equity2Ranks.get(equityIterator.next()).add(bucketRank); 
     183                    stock2Ranks.get(stockIterator.next()).add(bucketRank); 
    184184                } 
    185185            } 
    186186        } 
    187187 
    188         return equity2Ranks; 
    189     } 
    190  
    191     private Map<FactorRanks, Set<Equity>> assignEquitiesToSets(Set<Equity> equities, 
    192                                                                Map<Equity, List<Integer>> equity2Ranks) { 
    193         Map<FactorRanks, Set<Equity>> ranks2Equities = newHashMap(); 
     188        return stock2Ranks; 
     189    } 
     190 
     191    private Map<FactorRanks, Set<Stock>> assignEquitiesToSets(Set<Stock> stocks, 
     192                                                              Map<Stock, List<Integer>> stock2Ranks) { 
     193        Map<FactorRanks, Set<Stock>> ranks2Equities = newHashMap(); 
    194194        for (List<Integer> ranks : computeRankProduct(factors, factor2nBuckets)) { 
    195             ranks2Equities.put(new FactorRanks(ranks), new HashSet<Equity>()); 
    196         } 
    197         for (Equity equity : equities) { 
    198             ranks2Equities.get(new FactorRanks(equity2Ranks.get(equity))).add(equity); 
     195            ranks2Equities.put(new FactorRanks(ranks), new HashSet<Stock>()); 
     196        } 
     197        for (Stock stock : stocks) { 
     198            ranks2Equities.get(new FactorRanks(stock2Ranks.get(stock))).add(stock); 
    199199        } 
    200200 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/portfolio/PortfolioSeriesGenerator.java

    r1401 r1495  
    2727import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    2828import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import com.numericalmethod.algoquant.model.factormodel.FactorValueEvaluator; 
    3131import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
    … …  
    4949 
    5050    /** 
    51      * Creates an instance from market snapshots, and the factors used for partitioning the equity 
     51     * Creates an instance from market snapshots, and the factors used for partitioning the stock 
    5252     * universe. 
    5353     * 
    … …  
    7777     * @return the generated portfolios at each time instant 
    7878     */ 
    79     public RandomAccessCache<List<IndexedPortfolio<FactorRanks, Equity>>> generatePortfolios( 
    80         Set<Equity> equities, 
     79    public RandomAccessCache<List<IndexedPortfolio<FactorRanks, Stock>>> generatePortfolios( 
     80        Set<Stock> equities, 
    8181        DateTime startTime, 
    8282        DateTime endTime, 
    8383        Period stepSize) { 
    84         BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosCache = new BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>>(); 
     84        BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosCache = new BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>>(); 
    8585 
    8686        for (DateTime baseTime = startTime; !baseTime.plus(stepSize).isAfter(endTime); baseTime = baseTime.plus(stepSize)) { 
    8787            FactorValueLookup factorValueLookup = factorValueEvaluator.evaluateForEquities(equities, baseTime); 
    88             List<IndexedPortfolio<FactorRanks, Equity>> portfolios = portfolioSetGenerator.newPortfolios(equities, factorValueLookup); 
     88            List<IndexedPortfolio<FactorRanks, Stock>> portfolios = portfolioSetGenerator.newPortfolios(equities, factorValueLookup); 
    8989 
    9090            portfoliosCache.add(baseTime, portfolios); 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/portfolio/PortfolioSetGenerator.java

    r1366 r1495  
    2727import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    2828import com.numericalmethod.algoquant.data.type.portfolio.PortfolioUtils; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
    3131import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    … …  
    6060    } 
    6161 
    62     public List<IndexedPortfolio<FactorRanks, Equity>> newPortfolios( 
    63         Set<Equity> equities, 
     62    public List<IndexedPortfolio<FactorRanks, Stock>> newPortfolios( 
     63        Set<Stock> equities, 
    6464        FactorValueLookup factorValueLookup) { 
    6565        Map<Factor, Integer> factor2nBuckets = newHashMap(); 
    … …  
    7575            new TreeMap<FactorRanking.FactorRanks, Bucket<FactorRanking.FactorRanks>>(bucketing.sort(equities)); 
    7676 
    77         List<IndexedPortfolio<FactorRanks, Equity>> portfolios = 
    78             new ArrayList<IndexedPortfolio<FactorRanks, Equity>>(buckets.size()); 
     77        List<IndexedPortfolio<FactorRanks, Stock>> portfolios = 
     78            new ArrayList<IndexedPortfolio<FactorRanks, Stock>>(buckets.size()); 
    7979        for (Map.Entry<FactorRanks, Bucket<FactorRanks>> bucket : buckets.entrySet()) { 
    8080            portfolios.add( 
    81                 new IndexedPortfolio<FactorRanks, Equity>( 
     81                new IndexedPortfolio<FactorRanks, Stock>( 
    8282                bucket.getKey(), 
    83                 PortfolioUtils.newEqualWeightedPortfolio(bucket.getValue().getEquitySet()))); 
     83                PortfolioUtils.newEqualWeightedPortfolio(bucket.getValue().getStocks()))); 
    8484        } 
    8585        return portfolios; 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/crosssectional/CrossSectionalRegression.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.model.factormodel.regression.crosssectional; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
    2727import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    … …  
    3838 
    3939/** 
    40  * A cross-sectional regression computes the betas for the factors that 
    41  * may explain the returns of <i>multiple</i> assets, hence cross-section. 
     40 * A cross-sectional regression computes the factor exposures (betas for the factors) that explain 
     41 * the returns of <i>multiple</i> assets, hence cross-section. 
    4242 * 
    4343 * @author Ken Yiu 
    … …  
    4545public class CrossSectionalRegression { 
    4646 
    47     public static class Result {// TODO: add other statistics to the result 
     47    public static class Result { // TODO: add other statistics to the result 
    4848 
    49         private final Map<Factor, Double> regressedPremiums; 
     49        private final Map<Factor, Double> exposures; // factor exposures 
    5050 
    51         Result(Map<Factor, Double> regressedPremiums) { 
    52             this.regressedPremiums = regressedPremiums; 
     51        private Result(Map<Factor, Double> exposures) { 
     52            this.exposures = exposures; 
    5353        } 
    5454 
    55         public Map<Factor, Double> getRegressedPremiums() { 
    56             return Collections.unmodifiableMap(regressedPremiums); 
     55        public Map<Factor, Double> getExposures() { 
     56            return Collections.unmodifiableMap(exposures); 
    5757        } 
    5858    } 
    … …  
    6565    } 
    6666 
    67     public Result run( 
    68             Map<Equity, Double> returns, 
    69             List<Factor> factors) 
    70             throws Exception { 
    71         List<Equity> equities = new ArrayList<Equity>(returns.keySet()); 
     67    public Result run(Map<Stock, Double> returns, List<Factor> factors) throws Exception { 
     68        List<Stock> stocks = new ArrayList<Stock>(returns.keySet()); 
     69        final int N = stocks.size(); // number of assets 
     70        final int M = factors.size(); 
    7271 
    73         // construct the y = Ax linear equations 
    74         double[] r = new double[returns.size()]; 
    75         Vector[] rows = new Vector[returns.size()]; 
    76         for (int i = 0; i < equities.size(); ++i) { 
    77             Equity equity = equities.get(i); 
    78             double[] row = new double[factors.size()]; 
     72        // construct the R = B*F linear equations 
     73        double[] r = new double[N]; 
     74        Vector[] rows = new Vector[N]; 
     75        for (int i = 0; i < N; ++i) { 
     76            Stock stock = stocks.get(i); 
    7977 
    80             for (int j = 0; j < factors.size(); ++j) { 
    81                 row[j] = lookup.getValue(equity, factors.get(j)); 
     78            double[] row = new double[M]; 
     79            for (int j = 0; j < M; ++j) { 
     80                row[j] = lookup.getValue(stock, factors.get(j)); 
    8281            } 
     82            rows[i] = new DenseVector(row); 
    8383 
    84             rows[i] = new DenseVector(row); 
    85             r[i] = returns.get(equity); 
     84            r[i] = returns.get(stock); 
    8685        } 
    8786 
    88         Matrix X = CreateMatrix.rbind(rows); 
    89         Vector y = new DenseVector(r); 
     87        Matrix F = CreateMatrix.rbind(rows); // factors 
     88        Vector R = new DenseVector(r); // returns 
    9089 
    9190        try { 
    92             LMProblem crossSection = new LMProblem(y, X, false); // always turn off the intercept; use intercept factor instead 
    93             OLSRegression ols = new OLSRegression(crossSection); 
     91            LMProblem crossSectionalRegression = new LMProblem(R, F, false); // always turn off the intercept; use intercept factor instead 
     92            OLSRegression ols = new OLSRegression(crossSectionalRegression); 
    9493 
    95             Map<Factor, Double> regressedPremiums = newHashMap(); 
    96             for (int i = 0; i < factors.size(); i++) { 
    97                 regressedPremiums.put(factors.get(i), ols.beta().betaHat().get(i + 1)); 
     94            Map<Factor, Double> exposures = newHashMap(); 
     95            for (int i = 0; i < M; i++) { 
     96                exposures.put(factors.get(i), ols.beta().betaHat().get(i + 1)); 
    9897            } 
    99  
    100             return new Result(regressedPremiums); 
     98            return new Result(exposures); 
    10199        } catch (Exception ex) { 
    102             logger.error(String.format("failed in cross-sectional regression:%n%n%s%n%n%s%n", X, y), ex); 
     100            logger.error(String.format("failed in cross-sectional regression:%n%n%s%n%n%s%n", F, R), ex); 
    103101            throw new Exception(ex); 
    104102        } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/FamaMacBethRegression.java

    r1366 r1495  
    2525import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    2626import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    28 import com.numericalmethod.algoquant.model.factormodel.EquityFactorValues; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2928import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
     29import com.numericalmethod.algoquant.model.factormodel.StockFactorValues; 
    3030import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3131import com.numericalmethod.algoquant.model.factormodel.regression.crosssectional.CrossSectionalRegression; 
    … …  
    3636import static com.numericalmethod.nmutils.collection.CollectionUtils.newHashMap; 
    3737import static com.numericalmethod.suanshu.misc.ArgumentAssertion.assertTrue; 
    38 import java.util.ArrayList; 
    39 import java.util.List; 
    40 import java.util.Map; 
    41 import java.util.Set; 
    42 import org.joda.time.DateTime; 
    43 import org.joda.time.Interval; 
    44 import org.joda.time.Period; 
     38import java.util.*; 
     39import org.joda.time.*; 
    4540import org.slf4j.Logger; 
    4641 
    4742/** 
    48  * Performs the cross-sectional regression as explained in the Fama-MacBeth 
    49  * paper from 1973. 
     43 * Performs the cross-sectional regression as explained in the Fama-MacBeth paper from 1973. 
    5044 * <p/> 
    51  * Precisely, this implementation does the cross-sectional regressions over 
    52  * each given period. The returned {@link FamaMacBethRegressionResults} flexibly 
    53  * allows further processing, e.g., averaging the regressed coefficients. 
     45 * Precisely, this implementation does the cross-sectional regressions over each given period. The 
     46 * returned {@link FamaMacBethRegressionResults} flexibly allows further processing, e.g., averaging 
     47 * the regressed coefficients. 
    5448 * 
    5549 * @author Haksun Li 
    … …  
    8478     *         coefficients of the factors from the regression 
    8579     */ 
    86     public FamaMacBethRegressionResults run( 
    87         final Set<Equity> equities, 
    88         final List<Factor> factors, 
    89         DateTime startTime, 
    90         Period period, 
    91         int nPeriods) { 
     80    public FamaMacBethRegressionResults run(final Set<Stock> equities, 
     81                                            final List<Factor> factors, 
     82                                            DateTime startTime, 
     83                                            Period period, 
     84                                            int nPeriods) { 
    9285        assertTrue(factors.size() <= equities.size(), 
    9386                   "number of factors (%d) must be no bigger than number of companies (%d)", 
    … …  
    9992 
    10093        for (Interval interval : intervals) { 
    101             Map<Equity, Double> equityReturns = computeEquityReturns(equities, interval); 
     94            Map<Stock, Double> stockReturns = computeStockReturns(equities, interval); 
    10295            FactorValueLookup factorValueLookup = computeFactorExposures(equities, factors, interval.getStart()); 
    10396 
    … …  
    10598                // cross-sectional regression, eq. 10 
    10699                CrossSectionalRegression regression = new CrossSectionalRegression(factorValueLookup); 
    107                 CrossSectionalRegression.Result result = regression.run(equityReturns, factors); 
    108                 time2RegressedPremiums.put(interval.getStart(), result.getRegressedPremiums()); 
     100                CrossSectionalRegression.Result result = regression.run(stockReturns, factors); 
     101                time2RegressedPremiums.put(interval.getStart(), result.getExposures()); 
    109102            } catch (Exception ex) { 
    110103                logger.error(String.format("failed in regression at time %s", interval), ex); 
    … …  
    126119    } 
    127120 
    128     private Map<Equity, Double> computeEquityReturns(Set<Equity> equities, Interval interval) { 
    129         Map<Equity, Double> equityReturns = newHashMap(); 
    130         for (Equity equity : equities) { 
    131             equityReturns.put(equity, computeReturnForEquity(equity, interval)); 
     121    private Map<Stock, Double> computeStockReturns(Set<Stock> stocks, Interval interval) { 
     122        Map<Stock, Double> stockReturns = newHashMap(); 
     123        for (Stock stock : stocks) { 
     124            stockReturns.put(stock, computeReturnForEquity(stock, interval)); 
    132125        } 
    133         return equityReturns; 
     126        return stockReturns; 
    134127    } 
    135128 
    136     private double computeReturnForEquity(Equity equity, Interval interval) { 
    137         double priceStart = marketSnapshotCache.get(interval.getStart()).getData().getProfile(equity).getPrice(); 
    138         double priceEnd = marketSnapshotCache.get(interval.getEnd()).getData().getProfile(equity).getPrice(); 
     129    private double computeReturnForEquity(Stock stock, Interval interval) { 
     130        double priceStart = marketSnapshotCache.get(interval.getStart()).getData().getProfile(stock).getPrice(); 
     131        double priceEnd = marketSnapshotCache.get(interval.getEnd()).getData().getProfile(stock).getPrice(); 
    139132 
    140133        return RETURN_CALCULATOR.computeReturn(priceStart, priceEnd); 
    141134    } 
    142135 
    143     private FactorValueLookup computeFactorExposures(Set<Equity> equities, List<Factor> factors, 
    144         DateTime time) { 
    145         EquityFactorValues factorValues = new EquityFactorValues(); 
    146         for (Equity equity : equities) { 
     136    private FactorValueLookup computeFactorExposures(Set<Stock> stocks, List<Factor> factors, 
     137                                                     DateTime time) { 
     138        StockFactorValues factorValues = new StockFactorValues(); 
     139        for (Stock stock : stocks) { 
    147140            for (Factor factor : factors) { 
    148                 double factorValue = factor.getFactorExposure(equity, time, marketSnapshotCache); 
    149                 factorValues.put(factor, equity, factorValue); 
     141                double factorValue = factor.getFactorExposure(stock, time, marketSnapshotCache); 
     142                factorValues.put(factor, stock, factorValue); 
    150143            } 
    151144        } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/capm/CAPMEstimatorForPortfolio.java

    r1366 r1495  
    33import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    44import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    5 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     5import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    66import com.numericalmethod.algoquant.model.factormodel.capm.CAPM; 
    77import com.numericalmethod.algoquant.model.factormodel.capm.CAPMFromMonthlyData; 
    … …  
    3232        List<TimedEntry<PortfoliosSnapshot>> portfoliosSnapshots) { // TODO: should just pass in the required parameters instead of the whole thing 
    3333        Map<FactorRanks, CAPM> indexedCapm = newHashMap(); // p.431 3rd para. "full samples" 
    34         List<IndexedPortfolio<FactorRanks, Equity>> portfolios = portfoliosSnapshots.get(0).getData().getPortfolios(); 
    35         for (IndexedPortfolio<FactorRanks, Equity> portfolio : portfolios) { 
     34        List<IndexedPortfolio<FactorRanks, Stock>> portfolios = portfoliosSnapshots.get(0).getData().getPortfolios(); 
     35        for (IndexedPortfolio<FactorRanks, Stock> portfolio : portfolios) { 
    3636            FactorRanks index = portfolio.getIndex(); 
    3737            CAPM capm = estimateFromMonthlyData(portfoliosSnapshots, index); 
    … …  
    5454            PortfoliosSnapshot snapshot = timedSnapshot.getData(); 
    5555            returns.add(snapshot.getReturnsForPortfolioIndex(index)); 
    56             marketPrices.add(snapshot.getMarketSnapshot().getMarketValue()); 
     56            marketPrices.add(snapshot.getMarketSnapshot().getBenchmark()); 
    5757            rates.add(snapshot.getMarketSnapshot().getRiskFreeRate()); 
    5858        } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/capm/CAPMPerPortfolio.java

    r1366 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.equity.CompanyProfile; 
    26 import com.numericalmethod.algoquant.data.equity.measure.AccountingData; 
    27 import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    28 import com.numericalmethod.algoquant.data.equity.measure.TradingData; 
     26import com.numericalmethod.algoquant.data.equity.measure.*; 
    2927import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    3028import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    3129import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3331import com.numericalmethod.algoquant.model.factormodel.capm.CAPM; 
    3432import com.numericalmethod.algoquant.model.factormodel.factor.MeasureFactor; 
    … …  
    3634import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    3735import static com.numericalmethod.nmutils.collection.CollectionUtils.newHashMap; 
    38 import java.util.ArrayList; 
    39 import java.util.List; 
    40 import java.util.Map; 
     36import java.util.*; 
    4137import org.joda.time.DateTime; 
    4238 
    … …  
    6056 
    6157        @Override 
    62         public Equity getEquity() { 
    63             return profile.getEquity(); 
     58        public Stock getStock() { 
     59            return profile.getStock(); 
    6460        } 
    6561 
    … …  
    115111        } 
    116112    } 
     113 
    117114    private final CAPMEstimatorForPortfolio estimator; 
    118115 
    … …  
    139136            PortfoliosSnapshot snapshot = entry.getData(); 
    140137 
    141             List<CompanyProfile> profiles = snapshot.getMarketSnapshot().getProfiles(); 
     138            Collection<CompanyProfile> profiles = snapshot.getMarketSnapshot().getProfiles(); 
    142139            List<CompanyProfile> newProfiles = new ArrayList<CompanyProfile>(profiles.size()); 
    143             for (IndexedPortfolio<FactorRanks, Equity> portfolio : snapshot.getPortfolios()) { 
     140            for (IndexedPortfolio<FactorRanks, Stock> portfolio : snapshot.getPortfolios()) { 
    144141                FactorRanks index = portfolio.getIndex(); 
    145142 
    … …  
    151148 
    152149                for (CompanyProfile profile : profiles) { 
    153                     if (portfolio.getPortfolio().getProducts().contains(profile.getEquity())) { 
     150                    if (portfolio.getPortfolio().getProducts().contains(profile.getStock())) { 
    154151                        newProfiles.add(new OverridenCompanyProfile(profile, capmValues)); 
    155152                    } 
    … …  
    159156            PortfoliosSnapshot newSnapshot = new PortfoliosSnapshot( 
    160157                new MarketSnapshot( 
    161                 snapshot.getMarketSnapshot().getMarketValue(), 
    162                 snapshot.getMarketSnapshot().getRiskFreeRate(), 
    163                 newProfiles), 
     158                    snapshot.getMarketSnapshot().getBenchmark(), 
     159                    snapshot.getMarketSnapshot().getRiskFreeRate(), 
     160                    newProfiles), 
    164161                snapshot.getPortfolioReturns(), 
    165162                snapshot.getPortfolios()); 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/panel/FactorPanelRegression.java

    r1366 r1495  
    2525import com.numericalmethod.algoquant.data.cache.SequentialCache; 
    2626import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    28 import com.numericalmethod.algoquant.execution.product.equity.EquityComparatorBySymbol; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2928import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
    3029import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    31 import com.numericalmethod.nmutils.NMUtils; 
    3230import com.numericalmethod.suanshu.algebra.linear.matrix.doubles.Matrix; 
    3331import com.numericalmethod.suanshu.algebra.linear.matrix.doubles.operation.CreateMatrix; 
    … …  
    3937import static org.apache.commons.lang.ArrayUtils.toPrimitive; 
    4038import org.joda.time.DateTime; 
    41 import org.slf4j.Logger; 
    4239 
    4340/** 
    … …  
    4845public class FactorPanelRegression { 
    4946 
    50     private static final Logger logger = NMUtils.getClassLogger(); 
    5147    private final Map<DateTime, FactorValueLookup> lookup; 
    5248 
    … …  
    5652 
    5753    public FamaMacBethPanelRegressionResults run( 
    58             SequentialCache<Map<Equity, Double>> returnsCache, 
    59             List<Factor> factors) 
    60             throws Exception { 
     54        SequentialCache<Map<Stock, Double>> returnsCache, 
     55        List<Factor> factors) 
     56        throws Exception { 
    6157 
    6258        List<Matrix> exposureMatrices = new ArrayList<Matrix>(); 
    6359        List<Vector> returnVectors = new ArrayList<Vector>(); 
    6460 
    65         for (TimedEntry<Map<Equity, Double>> te : returnsCache) { 
     61        for (TimedEntry<Map<Stock, Double>> te : returnsCache) { 
    6662 
    6763            List<Vector> exposureMatrixRows = new ArrayList<Vector>(); 
    6864            List<Double> returnVectorItems = new ArrayList<Double>(); 
    6965 
    70             for (Equity equity : getSortedMap(te.getData()).keySet()) { 
     66            for (Stock stock : getSortedMap(te.getData()).keySet()) { 
    7167                List<Double> row = new ArrayList<Double>(); 
    7268 
    7369                for (Factor factor : factors) { 
    74                     row.add(lookup.get(te.getTime()).getValue(equity, factor)); 
     70                    row.add(lookup.get(te.getTime()).getValue(stock, factor)); 
    7571                } 
    7672 
    7773                exposureMatrixRows.add(new DenseVector(toPrimitive(row.toArray(new Double[0])))); 
    78                 returnVectorItems.add(te.getData().get(equity)); 
     74                returnVectorItems.add(te.getData().get(stock)); 
    7975            } 
    8076 
    … …  
    9187    } 
    9288 
    93     private SortedMap<Equity, Double> getSortedMap(Map<Equity, Double> map) { 
    94         SortedMap<Equity, Double> sortedMap = new TreeMap<Equity, Double>(new EquityComparatorBySymbol()); 
     89    private SortedMap<Stock, Double> getSortedMap(Map<Stock, Double> map) { 
     90        SortedMap<Stock, Double> sortedMap = new TreeMap<Stock, Double>(); 
    9591 
    96         for (Map.Entry<Equity, Double> entry : map.entrySet()) { 
     92        for (Map.Entry<Stock, Double> entry : map.entrySet()) { 
    9793            sortedMap.put(entry.getKey(), entry.getValue()); 
    9894        } 

  • core/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/panel/FamaMacBethPanelRegression.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.panel; 
    2424 
    25 import com.numericalmethod.algoquant.data.cache.BufferCache; 
    26 import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    27 import com.numericalmethod.algoquant.data.cache.SequentialCache; 
     25import com.numericalmethod.algoquant.data.cache.*; 
    2826import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    30 import com.numericalmethod.algoquant.model.factormodel.EquityFactorValues; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3128import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
     29import com.numericalmethod.algoquant.model.factormodel.StockFactorValues; 
    3230import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3331import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.FamaMacBethRegressionResults; 
    … …  
    3735import static com.numericalmethod.nmutils.collection.CollectionUtils.newHashMap; 
    3836import static com.numericalmethod.suanshu.misc.ArgumentAssertion.assertTrue; 
    39 import java.util.ArrayList; 
    40 import java.util.List; 
    41 import java.util.Map; 
    42 import java.util.Set; 
    43 import org.joda.time.DateTime; 
    44 import org.joda.time.Interval; 
    45 import org.joda.time.Period; 
     37import java.util.*; 
     38import org.joda.time.*; 
    4639 
    4740/** 
    … …  
    8578     */ 
    8679    public FamaMacBethPanelRegressionResults run( 
    87         final Set<Equity> equities, 
     80        final Set<Stock> equities, 
    8881        final List<Factor> factors, 
    8982        DateTime startTime, 
    … …  
    9992            computeFactorExposures(intervals, equities, factors); 
    10093 
    101         SequentialCache<Map<Equity, Double>> returnCache = 
    102             computeEquityReturns(intervals, equities); 
     94        SequentialCache<Map<Stock, Double>> returnCache = 
     95            computeStockReturns(intervals, equities); 
    10396 
    10497        FactorPanelRegression regression = new FactorPanelRegression(factorExposures); 
    … …  
    118111    } 
    119112 
    120     private SequentialCache<Map<Equity, Double>> computeEquityReturns( 
     113    private SequentialCache<Map<Stock, Double>> computeStockReturns( 
    121114        List<Interval> intervals, 
    122         Set<Equity> equities) { 
     115        Set<Stock> stocks) { 
    123116 
    124         BufferCache<Map<Equity, Double>> returnCache = new BufferCache<Map<Equity, Double>>(); 
     117        BufferCache<Map<Stock, Double>> returnCache = new BufferCache<Map<Stock, Double>>(); 
    125118 
    126119        for (Interval interval : intervals) { 
    127             Map<Equity, Double> equityReturns = newHashMap(); 
    128             for (Equity equity : equities) { 
    129                 equityReturns.put(equity, computeReturnForEquity(equity, interval)); 
     120            Map<Stock, Double> stockReturns = newHashMap(); 
     121            for (Stock stock : stocks) { 
     122                stockReturns.put(stock, computeStockReturns2(stock, interval)); 
    130123            } 
    131124 
    132             returnCache.add(interval.getStart(), equityReturns); 
     125            returnCache.add(interval.getStart(), stockReturns); 
    133126        } 
    134127 
    … …  
    136129    } 
    137130 
    138     private double computeReturnForEquity(Equity equity, Interval interval) { 
     131    private double computeStockReturns2(Stock stock, Interval interval) { 
    139132        double priceStart = marketSnapshotCache.get(interval.getStart()). 
    140             getData().getProfile(equity).getPrice(); 
     133            getData().getProfile(stock).getPrice(); 
    141134        double priceEnd = marketSnapshotCache.get(interval.getEnd()). 
    142             getData().getProfile(equity).getPrice(); 
     135            getData().getProfile(stock).getPrice(); 
    143136 
    144137        return RETURN_CALCULATOR.computeReturn(priceStart, priceEnd); 
    … …  
    147140    private Map<DateTime, FactorValueLookup> computeFactorExposures( 
    148141        List<Interval> intervals, 
    149         Set<Equity> equities, 
     142        Set<Stock> stocks, 
    150143        List<Factor> factors) { 
    151144 
    … …  
    154147        for (Interval interval : intervals) { 
    155148 
    156             EquityFactorValues factorValues = new EquityFactorValues(); 
    157             for (Equity equity : equities) { 
     149            StockFactorValues factorValues = new StockFactorValues(); 
     150            for (Stock stock : stocks) { 
    158151                for (Factor factor : factors) { 
    159152                    double factorValue = factor.getFactorExposure( 
    160                         equity, interval.getStart(), marketSnapshotCache); 
    161                     factorValues.put(factor, equity, factorValue); 
     153                        stock, interval.getStart(), marketSnapshotCache); 
     154                    factorValues.put(factor, stock, factorValue); 
    162155                } 
    163156            } 

  • core/src/main/java/com/numericalmethod/algoquant/model/portfoliooptimization/performance/PerformanceOptimizedYahooEODPortfolio.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.historicaldata.DepthCacheUtils; 
    2727import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    28 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     28import com.numericalmethod.algoquant.data.type.StockEOD; 
    2929import com.numericalmethod.algoquant.execution.performance.measure.ExchangeRateTable; 
    3030import com.numericalmethod.algoquant.execution.performance.measure.PerformanceMeasure; 
    3131import com.numericalmethod.algoquant.execution.product.Product; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     32import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3333import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    3434import com.numericalmethod.algoquant.execution.strategy.ProductParams; 
    3535import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    36 import java.util.ArrayList; 
    37 import java.util.Collections; 
    38 import java.util.List; 
    39 import java.util.Map; 
     36import java.util.*; 
    4037import org.joda.time.DateTime; 
    4138 
    … …  
    4441 * @author Haksun Li 
    4542 */ 
    46 public class PerformanceOptimizedYahooEODPortfolio extends PerformanceOptimizedPortfolio<EquityEOD> { 
     43public class PerformanceOptimizedYahooEODPortfolio extends PerformanceOptimizedPortfolio<StockEOD> { 
    4744 
    4845    public static interface YahooEODFactory { 
    4946 
    50         public YahooEOD newYahooEOD(Equity equity); 
     47        public YahooEOD newYahooEOD(Stock stock); 
    5148    } 
    5249 
    … …  
    5451 
    5552        protected final List<ProductParams> productParams; 
    56         private final Map<Product, CacheFactory<EquityEOD>> cacheFactories; 
     53        private final Map<Product, CacheFactory<StockEOD>> cacheFactories; 
    5754        private final ExchangeRateTable rates; 
    5855 
    … …  
    6259                new YahooEODFactory() { 
    6360                    @Override 
    64                     public YahooEOD newYahooEOD(Equity equity) { 
    65                         return new YahooEOD(equity, "./log/Yahoo", "./log/Yahoo"); 
     61                    public YahooEOD newYahooEOD(Stock stock) { 
     62                        return new YahooEOD(stock, "./log/Yahoo", "./log/Yahoo"); 
    6663                    } 
    6764                }, 
    … …  
    7067 
    7168        public Specification(List<ProductParams> productParams, YahooEODFactory yahooEodFactory, 
    72             ExchangeRateTable rates) { 
     69                             ExchangeRateTable rates) { 
    7370            this.productParams = new ArrayList<ProductParams>(productParams); 
    7471            this.cacheFactories = createSourceFactories(productParams, yahooEodFactory); 
    … …  
    8885                        depthCaches.addCache( 
    8986                            product, 
    90                             DepthCacheUtils.fromEquityEODCache(product, 
    91                                                                cacheFactories.get(product).getCache(begin, end))); 
     87                            DepthCacheUtils.fromStockEODCache(product, 
     88                                                              cacheFactories.get(product).getCache(begin, end))); 
    9289                    } 
    9390 
    … …  
    9996        } 
    10097 
    101         public Map<Product, CacheFactory<EquityEOD>> getCacheFactories() { 
     98        public Map<Product, CacheFactory<StockEOD>> getCacheFactories() { 
    10299            return Collections.unmodifiableMap(cacheFactories); 
    103100        } 
    … …  
    107104        } 
    108105 
    109         private static Map<Product, CacheFactory<EquityEOD>> createSourceFactories( 
     106        private static Map<Product, CacheFactory<StockEOD>> createSourceFactories( 
    110107            List<ProductParams> productParams, 
    111108            YahooEODFactory yahooEodFactory) { 
    112             Map<Product, CacheFactory<EquityEOD>> sourceFactories = newHashMap(16); 
     109            Map<Product, CacheFactory<StockEOD>> sourceFactories = newHashMap(16); 
    113110            for (ProductParams param : productParams) { 
    114111                Product product = param.product; 
    115                 Equity equityProduct = product.as(Equity.class); 
    116                 YahooEOD yahoo = yahooEodFactory.newYahooEOD(equityProduct); 
     112                Stock stockProduct = product.as(Stock.class); 
     113                YahooEOD yahoo = yahooEodFactory.newYahooEOD(stockProduct); 
    117114                sourceFactories.put(product, yahoo); 
    118115            } 

  • core/src/main/java/com/numericalmethod/algoquant/model/signal/volume/AccumulationDistributionLine.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.model.signal.volume; 
    2424 
    25 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     25import com.numericalmethod.algoquant.data.type.StockEOD; 
    2626import org.joda.time.DateTime; 
    2727 
    … …  
    4545 
    4646    @Override 
    47     public Double update(DateTime t, EquityEOD data) { 
     47    public Double update(DateTime t, StockEOD data) { 
    4848        super.update(data); 
    4949        this.value += super.getMoneyFlowVolume(); 

  • core/src/main/java/com/numericalmethod/algoquant/model/signal/volume/ChaikinMoneyFlow.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.model.signal.volume; 
    2424 
    25 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     25import com.numericalmethod.algoquant.data.type.StockEOD; 
    2626import com.numericalmethod.algoquant.model.signal.movingwindow.MovingWindowBySize; 
    2727import com.numericalmethod.suanshu.number.DoubleUtils; 
    … …  
    4848 
    4949    @Override 
    50     public Double update(DateTime t, EquityEOD data) { 
     50    public Double update(DateTime t, StockEOD data) { 
    5151        super.update(data); 
    5252        moneyFlowVolumeWindow.add(getMoneyFlowVolume()); 

  • core/src/main/java/com/numericalmethod/algoquant/model/signal/volume/ChaikinVolumeSignal.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.model.signal.volume; 
    2424 
    25 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     25import com.numericalmethod.algoquant.data.type.StockEOD; 
    2626import com.numericalmethod.algoquant.model.signal.DoubleSignal; 
    2727 
    … …  
    3232 * @author Johannes Lehmann 
    3333 */ 
    34 abstract class ChaikinVolumeSignal implements DoubleSignal<EquityEOD> { 
     34abstract class ChaikinVolumeSignal implements DoubleSignal<StockEOD> { 
    3535 
    3636    private double moneyFlowMultiplier; 
    … …  
    3838 
    3939    // Signature intentionally doesn't match that of interface, to force subclasses to implement their own update 
    40     public Double update(EquityEOD eod) { 
     40    public Double update(StockEOD eod) { 
    4141        this.moneyFlowMultiplier = ((eod.getClose() - eod.getLow()) - (eod.getHigh() - eod.getClose())) / (eod.getHigh() - eod.getLow()); 
    4242        this.moneyFlowVolume = moneyFlowMultiplier * eod.getVolume(); 

  • core/src/test/java/com/numericalmethod/algoquant/data/cache/conversion/Cache2MatrixTest.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.cache.conversion; 
    2424 
    25 import static com.numericalmethod.algoquant.data.cache.processor.transformer.DoubleEntryTransformers.EQUITYEOD; 
     25import static com.numericalmethod.algoquant.data.cache.processor.transformer.DoubleEntryTransformers.STOCK_EOD; 
    2626import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2828import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2929import com.numericalmethod.suanshu.algebra.linear.matrix.doubles.AreMatrices; 
    … …  
    4545    public void test_0010() { 
    4646        //setup data source 
    47         Equity GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Equity.class); 
     47        Stock GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Stock.class); 
    4848        DateTime begin = JodaTimeUtils.getDate(2010, 1, 1, Exchange.NASDAQ.timeZone); 
    4949        DateTime end = JodaTimeUtils.getDate(2010, 1, 10, Exchange.NASDAQ.timeZone); 
    … …  
    5555 
    5656        @SuppressWarnings("unchecked") 
    57         Cache2Matrix instance = new Cache2Matrix(EQUITYEOD.doProcess(GOOGsrc.getCache(begin, end))); 
     57        Cache2Matrix instance = new Cache2Matrix(STOCK_EOD.doProcess(GOOGsrc.getCache(begin, end))); 
    5858 
    5959//        System.out.println(instance); 
    … …  
    7373    public void test_0020() { 
    7474        //setup data source 
    75         Equity AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Equity.class); 
     75        Stock AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Stock.class); 
    7676        DateTime begin = JodaTimeUtils.getDate(2010, 1, 1, Exchange.NASDAQ.timeZone); 
    7777        DateTime end = JodaTimeUtils.getDate(2010, 1, 10, Exchange.NASDAQ.timeZone); 
    … …  
    8181                "./log/Yahoo"); 
    8282 
    83         Equity GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Equity.class); 
     83        Stock GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Stock.class); 
    8484        YahooEOD GOOGsrc = new YahooEOD( 
    8585                GOOG, 
    … …  
    8989        @SuppressWarnings("unchecked") 
    9090        Cache2Matrix instance = new Cache2Matrix( 
    91                 EQUITYEOD.doProcess(AAPLsrc.getCache(begin, end)), 
    92                 EQUITYEOD.doProcess(GOOGsrc.getCache(begin, end))); 
     91                STOCK_EOD.doProcess(AAPLsrc.getCache(begin, end)), 
     92                STOCK_EOD.doProcess(GOOGsrc.getCache(begin, end))); 
    9393 
    9494//        System.out.println(instance); 

  • core/src/test/java/com/numericalmethod/algoquant/data/cache/conversion/Cache2ReturnsMatrixTest.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.cache.conversion; 
    2424 
    25 import static com.numericalmethod.algoquant.data.cache.processor.transformer.DoubleEntryTransformers.EQUITYEOD; 
     25import static com.numericalmethod.algoquant.data.cache.processor.transformer.DoubleEntryTransformers.STOCK_EOD; 
    2626import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2828import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2929import com.numericalmethod.suanshu.algebra.linear.matrix.doubles.AreMatrices; 
    … …  
    4646    public void test_0010() { 
    4747        //setup data source 
    48         Equity VFINX = com.numericalmethod.algoquant.execution.product.equity.usa.VFINX.getInstance().as(Equity.class); 
     48        Stock VFINX = com.numericalmethod.algoquant.execution.product.equity.usa.VFINX.getInstance().as(Stock.class); 
    4949        DateTime begin = JodaTimeUtils.getDate(2010, 1, 1, Exchange.NASDAQ.timeZone); 
    5050        DateTime end = JodaTimeUtils.getDate(2010, 1, 10, Exchange.NASDAQ.timeZone); 
    … …  
    5353                "./test-data/Yahoo"); 
    5454 
    55         Equity GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Equity.class); 
     55        Stock GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Stock.class); 
    5656        YahooEOD GOOGsrc = new YahooEOD( 
    5757                GOOG, 
    … …  
    6060        @SuppressWarnings("unchecked") 
    6161        Cache2ReturnsMatrix instance = new Cache2ReturnsMatrix( 
    62                 EQUITYEOD.doProcess(VFINXsrc.getCache(begin, end)), EQUITYEOD.doProcess(GOOGsrc.getCache(begin, end))); 
     62                STOCK_EOD.doProcess(VFINXsrc.getCache(begin, end)), STOCK_EOD.doProcess(GOOGsrc.getCache(begin, end))); 
    6363 
    6464//        System.out.println(instance); 
    … …  
    7777    public void test_0020() { 
    7878        //setup data source 
    79         Equity GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Equity.class); 
     79        Stock GOOG = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance().as(Stock.class); 
    8080        DateTime begin = JodaTimeUtils.getDate(2009, 1, 1, Exchange.NASDAQ.timeZone); 
    8181        DateTime end = JodaTimeUtils.getDate(2010, 12, 31, Exchange.NASDAQ.timeZone); 
    … …  
    8484                "./test-data/Yahoo"); 
    8585 
    86         Equity AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Equity.class); 
     86        Stock AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Stock.class); 
    8787        YahooEOD AAPLsrc = new YahooEOD( 
    8888                AAPL, 
    … …  
    9191        @SuppressWarnings("unchecked") 
    9292        Cache2ReturnsMatrix returns = new Cache2ReturnsMatrix( 
    93                 EQUITYEOD.doProcess(GOOGsrc.getCache(begin, end)), EQUITYEOD.doProcess(AAPLsrc.getCache(begin, end))); 
     93                STOCK_EOD.doProcess(GOOGsrc.getCache(begin, end)), STOCK_EOD.doProcess(AAPLsrc.getCache(begin, end))); 
    9494 
    9595        SampleCovariance instance = new SampleCovariance(returns); 

  • core/src/test/java/com/numericalmethod/algoquant/data/equity/CompanyProfileTest.java

    r1492 r1495  
    2626import com.numericalmethod.algoquant.data.equity.measure.TradedPrice; 
    2727import com.numericalmethod.algoquant.data.equity.measure.TradingData; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3030import com.numericalmethod.algoquant.execution.product.equity.hkex.HKEXProduct; 
    … …  
    4343        CompanyMeasure price = new TradedPrice(); 
    4444 
    45         CompanyProfileImpl instance = new CompanyProfileImpl(new HKEXProduct("0005").as(Equity.class), new TradingData() { 
     45        CompanyProfileImpl instance = new CompanyProfileImpl(new HKEXProduct("0005").as(Stock.class), new TradingData() { 
    4646            @Override 
    4747            public DateTime getDate() { 

  • core/src/test/java/com/numericalmethod/algoquant/data/equity/filter/companyhistories/DummyCompanyHistory.java

    r1492 r1495  
    2828import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    2929import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    3130import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     31import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3232import com.numericalmethod.nmutils.iterator.AbstractReadOnlyIterator; 
    3333import java.util.Iterator; 
    … …  
    4848 
    4949    public DummyCompanyHistory(List<DateTime> dates) { 
    50         Equity equity = new Equity("Foo" + counter++, Exchange.HKEX); 
     50        Stock stock = new Stock("Foo" + counter++, Exchange.HKEX); 
    5151        this.history = new CompanyHistoryImpl( 
    52             equity, 
     52            stock, 
    5353            null, 
    54             newSequentialCache(dates, equity)); 
     54            newSequentialCache(dates, stock)); 
    5555    } 
    5656 
    5757    @Override 
    58     public Equity getEquity() { 
    59         return history.getEquity(); 
     58    public Stock getStock() { 
     59        return history.getStock(); 
    6060    } 
    6161 
    … …  
    6666 
    6767    private static SequentialCache<CompanyProfile> newSequentialCache(final List<DateTime> dates, 
    68                                                                       final Equity equity) { 
     68                                                                      final Stock stock) { 
    6969        return new SequentialCache<CompanyProfile>() { 
    7070            @Override 
    … …  
    8282                        return new TimedEntry<CompanyProfile>(datesIterator.next(), new CompanyProfile() { 
    8383                            @Override 
    84                             public Equity getEquity() { 
    85                                 return equity; 
     84                            public Stock getStock() { 
     85                                return stock; 
    8686                            } 
    8787 

  • core/src/test/java/com/numericalmethod/algoquant/data/equity/filter/companyhistories/SmallCapFilterTest.java

    r1492 r1495  
    7272 
    7373        for (CompanyHistory history : companyHistories) { 
    74             symbols.add(history.getEquity().getSymbol()); 
     74            symbols.add(history.getStock().getSymbol()); 
    7575        } 
    7676 

  • core/src/test/java/com/numericalmethod/algoquant/data/equity/filter/companyhistories/TestCompanyHistory.java

    r1492 r1495  
    2525import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    2626import com.numericalmethod.algoquant.data.cache.SequentialCache; 
    27 import com.numericalmethod.algoquant.data.equity.CompanyHistory; 
    28 import com.numericalmethod.algoquant.data.equity.CompanyHistoryImpl; 
    29 import com.numericalmethod.algoquant.data.equity.CompanyInfo; 
    30 import com.numericalmethod.algoquant.data.equity.CompanyProfile; 
     27import com.numericalmethod.algoquant.data.equity.*; 
    3128import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3330import java.util.Iterator; 
    3431import java.util.List; 
    … …  
    4239    private final CompanyHistory history; 
    4340 
    44     public TestCompanyHistory(Equity equity, final List<TimedEntry<CompanyProfile>> companyProfiles) { 
     41    public TestCompanyHistory(Stock stock, final List<TimedEntry<CompanyProfile>> companyProfiles) { 
    4542        this.history = new CompanyHistoryImpl( 
    46             equity, 
     43            stock, 
    4744            null, 
    4845            new SequentialCache<CompanyProfile>() { 
    … …  
    5552 
    5653    @Override 
    57     public Equity getEquity() { 
    58         return history.getEquity(); 
     54    public Stock getStock() { 
     55        return history.getStock(); 
    5956    } 
    6057 

  • core/src/test/java/com/numericalmethod/algoquant/data/equity/snapshot/MonthlyDataFromMarketSnapshotsTest.java

    r1492 r1495  
    3030import com.numericalmethod.algoquant.data.equity.measure.TradedPrice; 
    3131import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    3332import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    34 import java.util.Collections; 
    35 import java.util.Iterator; 
    36 import java.util.List; 
     33import com.numericalmethod.algoquant.execution.product.equity.Stock; 
     34import java.util.*; 
    3735import org.joda.time.DateTime; 
    3836import org.joda.time.Period; 
    … …  
    4543public class MonthlyDataFromMarketSnapshotsTest { 
    4644 
    47     private static final Equity equity = new Equity("01550906W", Exchange.HKEX); 
     45    private static final Stock stock = new Stock("01550906W", Exchange.HKEX); 
    4846 
    4947    @Test 
    … …  
    5149        RandomAccessCache<MarketSnapshot> marketSnapshotCache = generateTestMarketSnapshotCache(); 
    5250 
    53         MonthlyDataFromMarketSnapshots monthlyData = new MonthlyDataFromMarketSnapshots(marketSnapshotCache, equity); 
     51        MonthlyDataFromMarketSnapshots monthlyData = new MonthlyDataFromMarketSnapshots(marketSnapshotCache, stock); 
    5452 
    5553        Iterator<TimedEntry<MarketSnapshot>> marketSnapshotsIterator = marketSnapshotCache.iterator(); 
    … …  
    6765 
    6866            assertEquals("times are equal", currentMarketSnapshot.getTime(), times.get(currentIndex)); 
    69             assertEquals("market Prices are equal", currentMarketSnapshot.getData().getMarketValue(), market.get(currentIndex), 1e-15); 
     67            assertEquals("market Prices are equal", currentMarketSnapshot.getData().getBenchmark(), market.get(currentIndex), 1e-15); 
    7068 
    7169            currentIndex += 1; 
    … …  
    7674    public void test_0020() { 
    7775        RandomAccessCache<MarketSnapshot> marketSnapshotCache = generateTestMarketSnapshotCache(); 
    78         MonthlyDataFromMarketSnapshots monthlyData = new MonthlyDataFromMarketSnapshots(marketSnapshotCache, equity); 
     76        MonthlyDataFromMarketSnapshots monthlyData = new MonthlyDataFromMarketSnapshots(marketSnapshotCache, stock); 
    7977 
    8078        List<DateTime> times = monthlyData.getTimes(); 
    … …  
    108106            new CompanyProfile() { 
    109107                @Override 
    110                 public Equity getEquity() { 
    111                     return equity; 
     108                public Stock getStock() { 
     109                    return stock; 
    112110                } 
    113111 

  • core/src/test/java/com/numericalmethod/algoquant/data/export/BatchSimulationXmlWriterUtilsTest.java

    r1472 r1495  
    6161    @Test 
    6262    public void test_exportSensitivityAnalysisResults() throws Exception { 
    63         List<Product> products = ProductUtils.newEquityProductList( 
     63        List<Product> products = ProductUtils.newStockProductList( 
    6464            new String[]{ 
    6565            "AAPL", "GOOG", "AMZN", "IBM", "HPQ", "MSFT", "CSCO", "ORCL", "INTC", "YHOO"}, 

  • core/src/test/java/com/numericalmethod/algoquant/data/historicaldata/compustat/CompanyHistoryDBTest.java

    r1366 r1495  
    6161        CompanyProfile profile = entry.getData(); 
    6262 
    63         assertEquals(symbol, profile.getEquity().getSymbol()); 
     63        assertEquals(symbol, profile.getStock().getSymbol()); 
    6464    } 
    6565 
    … …  
    9696        for (String name : names) { 
    9797            CompanyHistory history = db.getCompanyHistory(name); 
    98             assertEquals(name, history.getEquity().getSymbol()); 
     98            assertEquals(name, history.getStock().getSymbol()); 
    9999        } 
    100100    } 
    … …  
    113113 
    114114        assertEquals(1, histories.size()); 
    115         assertEquals("01550906W", histories.get(0).getEquity().getSymbol()); 
     115        assertEquals("01550906W", histories.get(0).getStock().getSymbol()); 
    116116 
    117117    } 

  • core/src/test/java/com/numericalmethod/algoquant/data/historicaldata/compustat/TestMarketData.java

    r1492 r1495  
    66import com.numericalmethod.algoquant.data.equity.CompanyHistory; 
    77import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    8 import com.numericalmethod.algoquant.data.equity.measure.EquityMeasure; 
     8import com.numericalmethod.algoquant.data.equity.measure.StockMeasure; 
    99import com.numericalmethod.algoquant.data.equity.measure.MarketCap; 
    1010import com.numericalmethod.algoquant.data.equity.measure.PE; 
    … …  
    4040            new PE(), 
    4141            new MarketCap(), 
    42             new EquityMeasure(), 
     42            new StockMeasure(), 
    4343            new TradedVolume()))); 
    4444    public static final DateTime START_TIME = new DateTime(2001, 1, 1, 16, 0, TimeZoneUtils.HONG_KONG); 

  • core/src/test/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/MultipleYahooEODTest.java

    r1366 r1495  
    2525import com.numericalmethod.algoquant.data.cache.VectorCache.Vector; 
    2626import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2828import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2929import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    … …  
    4444        DateTime end = JodaTimeUtils.getDate(2011, 3, 31, Exchange.NASDAQ.timeZone); 
    4545 
    46         MultipleYahooEOD instance = new MultipleYahooEOD(new Equity[]{ 
    47                 com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.IBM.getInstance().as(Equity.class), 
    48                 com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.ORCL.getInstance().as(Equity.class)}, 
     46        MultipleYahooEOD instance = new MultipleYahooEOD(new Stock[]{ 
     47                com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.IBM.getInstance().as(Stock.class), 
     48                com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.ORCL.getInstance().as(Stock.class)}, 
    4949                                                         begin, end, 
    5050                                                         "./test-data/Yahoo", "./log/Yahoo"); 

  • core/src/test/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooEODCsvZipFileWriterTest.java

    r1395 r1495  
    2525import com.numericalmethod.algoquant.data.cache.BufferCache; 
    2626import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEODCsvZipFileReader.YahooRow; 
    27 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.data.type.StockEOD; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3030import com.numericalmethod.algoquant.execution.product.equity.hkex.HK0005; 
    … …  
    4848    public void test_0010() throws IOException, ParseException { 
    4949        YahooEODCsvZipFileWriter instance = new YahooEODCsvZipFileWriter("./log"); 
    50         int nRows = instance.saveAllFromWeb(HK0005.getInstance().as(Equity.class)); 
     50        int nRows = instance.saveAllFromWeb(HK0005.getInstance().as(Stock.class)); 
    5151 
    5252        YahooEODCsvZipFileReader reader = new YahooEODCsvZipFileReader("./test-data/Yahoo/0005.HK.csv.zip"); 
    … …  
    5858    public void test_0020() throws IOException, ParseException { 
    5959        YahooEODCsvZipFileWriter instance = new YahooEODCsvZipFileWriter("./log"); 
    60         int nRows = instance.saveAllFromWeb(AAPL.getInstance().as(Equity.class)); 
     60        int nRows = instance.saveAllFromWeb(AAPL.getInstance().as(Stock.class)); 
    6161 
    6262        YahooEODCsvZipFileReader reader = new YahooEODCsvZipFileReader("./test-data/Yahoo/AAPL.csv.zip"); 
    … …  
    6868    public void test_0030() throws IOException, ParseException { 
    6969        YahooEODCsvZipFileWriter instance = new YahooEODCsvZipFileWriter("./log"); 
    70         int nRows = instance.saveAllFromWeb(HSI.getInstance().as(Equity.class)); 
     70        int nRows = instance.saveAllFromWeb(HSI.getInstance().as(Stock.class)); 
    7171 
    7272        YahooEODCsvZipFileReader reader = new YahooEODCsvZipFileReader("./test-data/Yahoo/^HSI.csv.zip"); 
    … …  
    7979        String dataFolder = "./log/YahooEODCsvZipFileWriterTest"; 
    8080        YahooEODCsvZipFileWriter instance = new YahooEODCsvZipFileWriter(dataFolder); 
    81         BufferCache<EquityEOD> cache = new BufferCache<EquityEOD>(); 
     81        BufferCache<StockEOD> cache = new BufferCache<StockEOD>(); 
    8282        DateTime time = new DateTime(2011, 9, 16, 1, 2, 3, 4); 
    83         EquityEOD data = new EquityEOD(10, 15, 8, 12, 1000, 12); 
     83        StockEOD data = new StockEOD(10, 15, 8, 12, 1000, 12); 
    8484        cache.add(time, data); 
    85         int nRows = instance.save(new Equity("DUMMY", Exchange.HKEX), cache); 
     85        int nRows = instance.save(new Stock("DUMMY", Exchange.HKEX), cache); 
    8686 
    8787        assertEquals(1, nRows); 
    … …  
    108108    public void downloadData() throws IOException, ParseException { 
    109109        YahooEODCsvZipFileWriter instance = new YahooEODCsvZipFileWriter("./log/"); 
    110         instance.saveAllFromWeb(VFINX.getInstance().as(Equity.class)); 
     110        instance.saveAllFromWeb(VFINX.getInstance().as(Stock.class)); 
    111111    } 
    112112} 

  • core/src/test/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooEODTest.java

    r1407 r1495  
    2525import com.numericalmethod.algoquant.data.cache.SequentialCache; 
    2626import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    27 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.data.type.StockEOD; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.nmutils.io.NMIO; 
    3030import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    … …  
    5555    @Test 
    5656    public void test_loadFromFile_0010() { 
    57         Equity HK0005 = com.numericalmethod.algoquant.execution.product.equity.hkex.HK0005.getInstance().as(Equity.class); 
     57        Stock HK0005 = com.numericalmethod.algoquant.execution.product.equity.hkex.HK0005.getInstance().as(Stock.class); 
    5858        DateTime begin = JodaTimeUtils.getDate(2003, 1, 1, HK0005.getExchange().timeZone); 
    5959        DateTime end = JodaTimeUtils.getDate(2003, 1, 10, HK0005.getExchange().timeZone); 
    60         SequentialCache<EquityEOD> instance = 
     60        SequentialCache<StockEOD> instance = 
    6161            new YahooEOD(HK0005, "./test-data/Yahoo", getTestFolderName()).getCache(begin, end); 
    6262 
    6363        int count = 0; 
    64         for (TimedEntry<EquityEOD> entry : instance) { 
     64        for (TimedEntry<StockEOD> entry : instance) { 
    6565            ++count; 
    6666        } 
    … …  
    7474    @Test 
    7575    public void test_notEnoughData_0010() { 
    76         Equity AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Equity.class); 
     76        Stock AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Stock.class); 
    7777        DateTime begin = JodaTimeUtils.getDate(1984, 9, 5, AAPL.getExchange().timeZone); // there is no data from web on 9-5 and 9-6 
    7878        DateTime end = JodaTimeUtils.getDate(1984, 9, 10, AAPL.getExchange().timeZone); 
    79         SequentialCache<EquityEOD> instance = 
     79        SequentialCache<StockEOD> instance = 
    8080            new YahooEOD(AAPL, "./test-data/Yahoo/partial", getTestFolderName()).getCache(begin, end); 
    8181 
    8282        int count = 0; 
    83         for (TimedEntry<EquityEOD> entry : instance) { 
     83        for (TimedEntry<StockEOD> entry : instance) { 
    8484            ++count; 
    8585        } 
    … …  
    9595    @Test 
    9696    public void test_notEnoughData_0020() { 
    97         Equity AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Equity.class); 
     97        Stock AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Stock.class); 
    9898        DateTime begin = JodaTimeUtils.getDate(1984, 9, 7, AAPL.getExchange().timeZone); 
    9999        DateTime end = JodaTimeUtils.getDate(1984, 10, 1, AAPL.getExchange().timeZone); 
    100         SequentialCache<EquityEOD> instance = 
     100        SequentialCache<StockEOD> instance = 
    101101            new YahooEOD(AAPL, "./test-data/Yahoo/partial", getTestFolderName()).getCache(begin, end); 
    102102 
    103103        int count = 0; 
    104         for (TimedEntry<EquityEOD> entry : instance) { 
     104        for (TimedEntry<StockEOD> entry : instance) { 
    105105            ++count; 
    106106        } 
    … …  
    113113    @Test 
    114114    public void test_alwaysDownloadFromWeb() { 
    115         Equity AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Equity.class); 
     115        Stock AAPL = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.AAPL.getInstance().as(Stock.class); 
    116116        DateTime begin = JodaTimeUtils.getDate(1984, 9, 7, AAPL.getExchange().timeZone); 
    117117        DateTime end = JodaTimeUtils.getDate(1984, 10, 1, AAPL.getExchange().timeZone); 
    118         SequentialCache<EquityEOD> instance = new YahooEOD(AAPL).getCache(begin, end); 
     118        SequentialCache<StockEOD> instance = new YahooEOD(AAPL).getCache(begin, end); 
    119119 
    120120        int count = 0; 
    121         for (TimedEntry<EquityEOD> entry : instance) { 
     121        for (TimedEntry<StockEOD> entry : instance) { 
    122122            ++count; 
    123123        } 
    … …  
    127127    @Test 
    128128    public void test_multipleInstancesOfTheSameSource() { 
    129         Equity HK0005 = com.numericalmethod.algoquant.execution.product.equity.hkex.HK0005.getInstance().as(Equity.class); 
     129        Stock HK0005 = com.numericalmethod.algoquant.execution.product.equity.hkex.HK0005.getInstance().as(Stock.class); 
    130130        DateTime begin = JodaTimeUtils.getDate(2004, 1, 1, HK0005.getExchange().timeZone); 
    131131        DateTime end = JodaTimeUtils.getDate(2006, 1, 1, HK0005.getExchange().timeZone); 
    132132        YahooEOD source = new YahooEOD(HK0005, "./test-data/Yahoo", getTestFolderName()); 
    133133 
    134         SequentialCache<EquityEOD> instance1 = source.getCache( 
     134        SequentialCache<StockEOD> instance1 = source.getCache( 
    135135            JodaTimeUtils.getDate(2005, 1, 1, HK0005.getExchange().timeZone), 
    136136            JodaTimeUtils.getDate(2005, 1, 10, HK0005.getExchange().timeZone)); 
    137137 
    138         SequentialCache<EquityEOD> instance2 = source.getCache( 
     138        SequentialCache<StockEOD> instance2 = source.getCache( 
    139139            JodaTimeUtils.getDate(2004, 12, 20, HK0005.getExchange().timeZone), 
    140140            JodaTimeUtils.getDate(2005, 1, 10, HK0005.getExchange().timeZone)); 
    141141 
    142142        int count1 = 0, count2 = 0; 
    143         for (TimedEntry<EquityEOD> entry : instance1) { 
     143        for (TimedEntry<StockEOD> entry : instance1) { 
    144144            if (entry != null) { 
    145145                ++count1; 
    146146            } 
    147147        } 
    148         for (TimedEntry<EquityEOD> entry : instance2) { 
     148        for (TimedEntry<StockEOD> entry : instance2) { 
    149149            if (entry != null) { 
    150150                ++count2; 

  • core/src/test/java/com/numericalmethod/algoquant/data/historicaldata/yahoo/YahooEODWebDownloaderTest.java

    r1366 r1495  
    2525import com.numericalmethod.algoquant.data.cache.SequentialCache; 
    2626import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    27 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     27import com.numericalmethod.algoquant.data.type.StockEOD; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3030import com.numericalmethod.algoquant.execution.product.equity.hkex.HK0005; 
    … …  
    4545        final DateTime endDate = JodaTimeUtils.getDate(2010, 11, 12, Exchange.HKEX.timeZone); 
    4646 
    47         SequentialCache<EquityEOD> instance = new YahooEODWebDownloader(HK0005.getInstance().as(Equity.class)).getCache(startDate, endDate); 
     47        SequentialCache<StockEOD> instance = new YahooEODWebDownloader(HK0005.getInstance().as(Stock.class)).getCache(startDate, endDate); 
    4848 
    4949        int count = 0; 
    50         for (TimedEntry<EquityEOD> entry : instance) { 
     50        for (TimedEntry<StockEOD> entry : instance) { 
    5151            count++; 
    5252        } 
    … …  
    6060        final DateTime endDate = JodaTimeUtils.getDate(2010, 11, 12, Exchange.NASDAQ.timeZone); 
    6161 
    62         SequentialCache<EquityEOD> instance = new YahooEODWebDownloader(HK0005.getInstance().as(Equity.class)).getCache(startDate, endDate); 
     62        SequentialCache<StockEOD> instance = new YahooEODWebDownloader(HK0005.getInstance().as(Stock.class)).getCache(startDate, endDate); 
    6363 
    6464        int count = 0; 
    65         for (TimedEntry<EquityEOD> entry : instance) { 
     65        for (TimedEntry<StockEOD> entry : instance) { 
    6666            count++; 
    6767        } 
    … …  
    7272    @Test 
    7373    public void test_getCache_0010() { 
    74         YahooEODWebDownloader source = new YahooEODWebDownloader(HK0005.getInstance().as(Equity.class)); 
     74        YahooEODWebDownloader source = new YahooEODWebDownloader(HK0005.getInstance().as(Stock.class)); 
    7575 
    76         SequentialCache<EquityEOD> instance1 = source.getCache(JodaTimeUtils.getDate(2010, 11, 5, Exchange.HKEX.timeZone), 
     76        SequentialCache<StockEOD> instance1 = source.getCache(JodaTimeUtils.getDate(2010, 11, 5, Exchange.HKEX.timeZone), 
    7777                                                               JodaTimeUtils.getDate(2010, 11, 12, Exchange.HKEX.timeZone)); 
    7878 
    79         SequentialCache<EquityEOD> instance2 = source.getCache( 
     79        SequentialCache<StockEOD> instance2 = source.getCache( 
    8080            JodaTimeUtils.getDate(2010, 11, 5, Exchange.HKEX.timeZone), 
    8181            JodaTimeUtils.getDate(2010, 11, 15, Exchange.HKEX.timeZone)); 
    8282 
    8383        int count1 = 0, count2 = 0; 
    84         for (TimedEntry<EquityEOD> entry : instance1) { 
     84        for (TimedEntry<StockEOD> entry : instance1) { 
    8585            if (entry != null) { 
    8686                ++count1; 
    8787            } 
    8888        } 
    89         for (TimedEntry<EquityEOD> entry : instance2) { 
     89        for (TimedEntry<StockEOD> entry : instance2) { 
    9090            if (entry != null) { 
    9191                ++count2; 

  • core/src/test/java/com/numericalmethod/algoquant/data/type/portfolio/weighting/RankWeightingTest.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.type.portfolio.weighting; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2727import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    3838    @Test 
    3939    public void test_getWeightsFromFactorsEvenNumberOfEquities_0010() { 
    40         Map<Equity, Double> factorValues = newHashMap(); 
     40        Map<Stock, Double> factorValues = newHashMap(); 
    4141        for (int i = 1; i <= 100; i++) { 
    42             factorValues.put(new Equity(Integer.toString(i), Exchange.HKEX), (double) i); 
     42            factorValues.put(new Stock(Integer.toString(i), Exchange.HKEX), (double) i); 
    4343        } 
    44         RankWeighting<Equity> weighting = new RankWeighting<Equity>(); 
     44        RankWeighting<Stock> weighting = new RankWeighting<Stock>(); 
    4545 
    46         Map<Equity, Double> weights = weighting.computeWeights(factorValues); 
     46        Map<Stock, Double> weights = weighting.computeWeights(factorValues); 
    4747 
    48         for (Map.Entry<Equity, Double> weight : weights.entrySet()) { 
     48        for (Map.Entry<Stock, Double> weight : weights.entrySet()) { 
    4949            double factorValue = factorValues.get(weight.getKey()); 
    5050 
    … …  
    5959    @Test 
    6060    public void test_getWeightsFromFactorsOddNumberOfEquities_0010() { 
    61         Map<Equity, Double> factorValues = newHashMap(); 
     61        Map<Stock, Double> factorValues = newHashMap(); 
    6262        for (int i = 1; i <= 101; i++) { 
    63             factorValues.put(new Equity(Integer.toString(i), Exchange.HKEX), (double) i); 
     63            factorValues.put(new Stock(Integer.toString(i), Exchange.HKEX), (double) i); 
    6464        } 
    65         RankWeighting<Equity> weighting = new RankWeighting<Equity>(); 
     65        RankWeighting<Stock> weighting = new RankWeighting<Stock>(); 
    6666 
    67         Map<Equity, Double> weights = weighting.computeWeights(factorValues); 
     67        Map<Stock, Double> weights = weighting.computeWeights(factorValues); 
    6868 
    69         for (Map.Entry<Equity, Double> weight : weights.entrySet()) { 
     69        for (Map.Entry<Stock, Double> weight : weights.entrySet()) { 
    7070            double factorValue = factorValues.get(weight.getKey()); 
    7171 

  • core/src/test/java/com/numericalmethod/algoquant/data/type/portfolio/weighting/TopBottomQuantilesEqualWeightingTest.java

    r1366 r1495  
    2323package com.numericalmethod.algoquant.data.type.portfolio.weighting; 
    2424 
    25 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     25import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2626import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2727import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    3737    @Test(expected = IllegalArgumentException.class) 
    3838    public void test_tooSmallQ_0010() { 
    39         TopBottomQuantilesEqualWeighting<Equity> weighting = new TopBottomQuantilesEqualWeighting<Equity>(1); 
     39        TopBottomQuantilesEqualWeighting<Stock> weighting = new TopBottomQuantilesEqualWeighting<Stock>(1); 
    4040    } 
    4141 
    4242    @Test(expected = IllegalArgumentException.class) 
    4343    public void test_tooFewEquities_0010() { 
    44         Map<Equity, Double> factorValues = newHashMap(); 
     44        Map<Stock, Double> factorValues = newHashMap(); 
    4545        for (int i = 1; i <= 99; i++) { 
    46             factorValues.put(new Equity(Integer.toString(i), Exchange.HKEX), (double) i); 
     46            factorValues.put(new Stock(Integer.toString(i), Exchange.HKEX), (double) i); 
    4747        } 
    4848 
    49         TopBottomQuantilesEqualWeighting<Equity> weighting = new TopBottomQuantilesEqualWeighting<Equity>(100); 
     49        TopBottomQuantilesEqualWeighting<Stock> weighting = new TopBottomQuantilesEqualWeighting<Stock>(100); 
    5050        weighting.computeWeights(factorValues); 
    5151    } 
    … …  
    5353    @Test 
    5454    public void test_getWeightsFromFactors_0010() { 
    55         Map<Equity, Double> factorValues = newHashMap(); 
     55        Map<Stock, Double> factorValues = newHashMap(); 
    5656        for (int i = 1; i <= 100; i++) { 
    57             factorValues.put(new Equity(Integer.toString(i), Exchange.HKEX), (double) i); 
     57            factorValues.put(new Stock(Integer.toString(i), Exchange.HKEX), (double) i); 
    5858        } 
    5959 
    60         TopBottomQuantilesEqualWeighting<Equity> weighting = new TopBottomQuantilesEqualWeighting<Equity>(5); 
     60        TopBottomQuantilesEqualWeighting<Stock> weighting = new TopBottomQuantilesEqualWeighting<Stock>(5); 
    6161 
    62         Map<Equity, Double> weights = weighting.computeWeights(factorValues); 
     62        Map<Stock, Double> weights = weighting.computeWeights(factorValues); 
    6363 
    6464        checkWeightCounts(weights, 20); 
    6565 
    6666        // check weight values 
    67         for (Map.Entry<Equity, Double> weight : weights.entrySet()) { 
     67        for (Map.Entry<Stock, Double> weight : weights.entrySet()) { 
    6868            double factorValue = factorValues.get(weight.getKey()); 
    6969            double weightValue = weight.getValue(); 
    … …  
    7676    } 
    7777 
    78     private static void checkWeightCounts(Map<Equity, Double> weights, int quantileSize) { 
     78    private static void checkWeightCounts(Map<Stock, Double> weights, int quantileSize) { 
    7979        int nNeg = 0; 
    8080        int nPos = 0; 
    81         for (Map.Entry<Equity, Double> weight : weights.entrySet()) { 
     81        for (Map.Entry<Stock, Double> weight : weights.entrySet()) { 
    8282            if (weight.getValue() > 0.0) { 
    8383                nPos++; 

  • core/src/test/java/com/numericalmethod/algoquant/execution/depth/SimulatedDepthCacheTest.java

    r1366 r1495  
    3030import com.numericalmethod.algoquant.data.type.Depth; 
    3131import com.numericalmethod.algoquant.execution.depth.returns.ReturnsGenerator; 
    32 import com.numericalmethod.algoquant.execution.product.Currencies; 
    33 import com.numericalmethod.algoquant.execution.product.Product; 
    34 import com.numericalmethod.algoquant.execution.product.ProductUtils; 
    35 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     32import com.numericalmethod.algoquant.execution.product.*; 
    3633import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     34import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3735import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    3836import com.numericalmethod.algoquant.model.returns.ReturnCalculators; 
    3937import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    40 import java.util.ArrayList; 
    41 import java.util.Iterator; 
    42 import java.util.List; 
     38import java.util.*; 
    4339import org.joda.time.DateTime; 
    4440import org.joda.time.Period; 
    … …  
    6056        } 
    6157    } 
     58 
    6259    private static final Product PRODUCT = HSI.getInstance(); 
    6360 
    … …  
    120117    @Test 
    121118    public void test_0020() { 
    122         Product product = ProductUtils.newEquityProduct("XOM", Exchange.NYSE, Currencies.USD); 
    123         Equity equity = product.as(Equity.class); 
    124         DateTime begin = JodaTimeUtils.getDate(2012, 5, 21, equity.getExchange().timeZone); 
     119        Product product = ProductUtils.newStockProduct("XOM", Exchange.NYSE, Currencies.USD); 
     120        Stock stock = product.as(Stock.class); 
     121        DateTime begin = JodaTimeUtils.getDate(2012, 5, 21, stock.getExchange().timeZone); 
    125122        DateTime end = begin.plusDays(4); 
    126         YahooEOD yahoo = new YahooEOD(equity, "./log/Yahoo", "./log/Yahoo"); 
    127         SequentialCache<Depth> modelCache = DepthCacheUtils.fromEquityEODCache(product, yahoo.getCache(begin, end));; 
     123        YahooEOD yahoo = new YahooEOD(stock, "./log/Yahoo", "./log/Yahoo"); 
     124        SequentialCache<Depth> modelCache = DepthCacheUtils.fromStockEODCache(product, yahoo.getCache(begin, end));; 
    128125 
    129126        SequentialCache<Depth> simulatedCache = new SimulatedDepthCache( 
    … …  
    143140        for (int i = 0; i < 4; i++) { 
    144141            TimedEntry<Depth> timedDepth = depths.get(i); 
    145             DateTime closingTime = equity.getExchange().getClosingTimeOnDate( 
    146                 new DateTime(2012, 5, 21, 0, 0, 0, equity.getExchange().timeZone).plusDays(i)); 
     142            DateTime closingTime = stock.getExchange().getClosingTimeOnDate( 
     143                new DateTime(2012, 5, 21, 0, 0, 0, stock.getExchange().timeZone).plusDays(i)); 
    147144            assertEquals(closingTime, timedDepth.getTime()); 
    148145            if (i > 0) { 

  • core/src/test/java/com/numericalmethod/algoquant/execution/product/equity/StockTest.java

    r1484 r1495  
    3030 * @author Haksun Li 
    3131 */ 
    32 public class EquityTest { 
     32public class StockTest { 
    3333 
    3434    @Test 
    3535    public void test_0010() { 
    36         Equity instance1 = new Equity("SAME", Exchange.HKEX); 
    37         Equity instance2 = new Equity("SAME", Exchange.HKEX); 
     36        Stock instance1 = new Stock("SAME", Exchange.HKEX); 
     37        Stock instance2 = new Stock("SAME", Exchange.HKEX); 
    3838        assertEquals(instance1, instance2); 
    3939        assertEquals(instance1.hashCode(), instance2.hashCode()); 
    … …  
    4242    @Test 
    4343    public void test_0020() { 
    44         Equity instance1 = new Equity("instance1", Exchange.HKEX); 
    45         Equity instance2 = new Equity("instance2", Exchange.HKEX); 
     44        Stock instance1 = new Stock("instance1", Exchange.HKEX); 
     45        Stock instance2 = new Stock("instance2", Exchange.HKEX); 
    4646        assertFalse(instance1.equals(instance2)); 
    4747        assertFalse(instance1.hashCode() == instance2.hashCode()); 

  • core/src/test/java/com/numericalmethod/algoquant/execution/simulator/SimpleSimulatorTest.java

    r1366 r1495  
    3030import com.numericalmethod.algoquant.execution.component.chart.plotter.NoOpPlotter; 
    3131import com.numericalmethod.algoquant.execution.component.tradeblotter.TradeBlotter; 
    32 import com.numericalmethod.algoquant.execution.order.BasicOrderDescription; 
    33 import com.numericalmethod.algoquant.execution.order.Order; 
    34 import com.numericalmethod.algoquant.execution.order.OrderUtils; 
     32import com.numericalmethod.algoquant.execution.order.*; 
    3533import com.numericalmethod.algoquant.execution.product.Product; 
    36 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     34import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3735import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    38 import com.numericalmethod.algoquant.execution.simulator.handler.ChannelMessageHandler; 
    39 import com.numericalmethod.algoquant.execution.simulator.handler.ChannelMessageHandlerFactory; 
    40 import com.numericalmethod.algoquant.execution.simulator.handler.NoOpMessageHandler; 
     36import com.numericalmethod.algoquant.execution.simulator.handler.*; 
    4137import com.numericalmethod.algoquant.execution.simulator.market.LimitOrderExecutionModel; 
    4238import com.numericalmethod.algoquant.execution.simulator.market.StrictFillModel; 
    … …  
    4844import com.numericalmethod.algoquant.execution.strategy.handler.UpdateHandler; 
    4945import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    50 import java.util.ArrayList; 
    51 import java.util.Collections; 
    52 import java.util.List; 
     46import java.util.*; 
    5347import org.joda.time.DateTime; 
    5448import org.joda.time.DateTimeZone; 
    … …  
    6660 
    6761    static { 
    68         Equity equity = PRODUCT.as(Equity.class); 
    69         DateTimeZone tz = equity.getExchange().timeZone; 
     62        Stock stock = PRODUCT.as(Stock.class); 
     63        DateTimeZone tz = stock.getExchange().timeZone; 
    7064        DateTime begin = JodaTimeUtils.getDate(2000, 1, 1, tz); 
    7165        DateTime end = JodaTimeUtils.getDate(2001, 3, 1, tz); 
    72         YahooEOD yahoo = new YahooEOD(equity, "./test-data/Yahoo", "./log/Yahoo"); 
     66        YahooEOD yahoo = new YahooEOD(stock, "./test-data/Yahoo", "./log/Yahoo"); 
    7367        DEPTH_CACHES = DepthCaches.newInstanceWithSingleCache( 
    74             PRODUCT, DepthCacheUtils.fromEquityEODCache(PRODUCT, yahoo.getCache(begin, end))); 
     68            PRODUCT, DepthCacheUtils.fromStockEODCache(PRODUCT, yahoo.getCache(begin, end))); 
    7569    } 
    7670 
    … …  
    8882            broker.sendOrder(Collections.singletonList( 
    8983                OrderUtils.newLimitOrder( 
    90                 PRODUCT, BasicOrderDescription.Side.BUY, 1.0, depth.ask(1)))); 
     84                    PRODUCT, BasicOrderDescription.Side.BUY, 1.0, depth.ask(1)))); 
    9185            ordersCounter++; 
    9286        } 
    … …  
    114108        Simulator extendedSimulator = 
    115109            new SimpleSimulator.Builder(DEPTH_CACHES).useLimitOrderExecutionModel( 
    116             new LimitOrderExecutionModel() { 
    117                 @Override 
    118                 public double getExecutedQuantity(Depth currentDepth, Order order) { 
    119                     return 0.0; // never execute order 
    120                 } 
    121  
    122                 @Override 
    123                 public double getExecutedPrice(Depth currentDepth, Order order) { 
    124                     throw new UnsupportedOperationException("Shouldn't be called!"); 
    125                 } 
    126             }).build(); 
     110                new LimitOrderExecutionModel() { 
     111                    @Override 
     112                    public double getExecutedQuantity(Depth currentDepth, Order order) { 
     113                        return 0.0; // never execute order 
     114                    } 
     115 
     116                    @Override 
     117                    public double getExecutedPrice(Depth currentDepth, Order order) { 
     118                        throw new UnsupportedOperationException("Shouldn't be called!"); 
     119                    } 
     120                }).build(); 
    127121        AlwaysLimitOrderStrategy strategy = new AlwaysLimitOrderStrategy(); 
    128122        TradeBlotter blotter = extendedSimulator.run(strategy, new NoOpPlotter()); 
    … …  
    156150            } 
    157151        } 
     152 
    158153    } 
    159154 
    … …  
    179174        Simulator simulator = 
    180175            new SimpleSimulator.Builder(DEPTH_CACHES).withCustomMessageHandlers( 
    181             new ChannelMessageHandlerFactory() { 
    182                 @Override 
    183                 public Class<? extends Subscribable> getSubscriberClass() { 
    184                     return MessageTypeA.class; 
    185                 } 
    186  
    187                 @Override 
    188                 public ChannelMessageHandler newHandler(UpdateHandler handler) { 
    189                     if (handler instanceof MessageTypeA.UpdateHandlerA) { 
    190                         return new MessageTypeA.MessageHandlerA((MessageTypeA.UpdateHandlerA) handler); 
    191                     } 
    192                     return new NoOpMessageHandler(); 
    193                 } 
    194             }).withNonDepthUpdates(msgAcache). 
     176                new ChannelMessageHandlerFactory() { 
     177                    @Override 
     178                    public Class<? extends Subscribable> getSubscriberClass() { 
     179                        return MessageTypeA.class; 
     180                    } 
     181 
     182                    @Override 
     183                    public ChannelMessageHandler newHandler(UpdateHandler handler) { 
     184                        if (handler instanceof MessageTypeA.UpdateHandlerA) { 
     185                            return new MessageTypeA.MessageHandlerA((MessageTypeA.UpdateHandlerA) handler); 
     186                        } 
     187                        return new NoOpMessageHandler(); 
     188                    } 
     189                }).withNonDepthUpdates(msgAcache). 
    195190            build(); 
    196  
    197191 
    198192        MessageTypeAStrategy strategy = new MessageTypeAStrategy(); 

  • core/src/test/java/com/numericalmethod/algoquant/model/analysis/cointegration/MovingCointegrationTest.java

    r1403 r1495  
    2424 
    2525import com.numericalmethod.algoquant.data.historicaldata.yahoo.MultipleYahooEOD; 
    26 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     26import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2727import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    2828import com.numericalmethod.suanshu.algebra.linear.vector.doubles.Vector; 
    … …  
    4646 
    4747        MultipleYahooEOD feed = new MultipleYahooEOD( 
    48                 new Equity[]{ 
    49             com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.IBM.getInstance().as(Equity.class), 
    50             com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.ORCL.getInstance().as(Equity.class)}, 
     48                new Stock[]{ 
     49            com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.IBM.getInstance().as(Stock.class), 
     50            com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.ORCL.getInstance().as(Stock.class)}, 
    5151                begin, end, 
    5252                "./test-data/Yahoo", "./log/Yahoo"); 
    … …  
    7272 
    7373        MultipleYahooEOD feed = new MultipleYahooEOD( 
    74                 new Equity[]{ 
    75             com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.IBM.getInstance().as(Equity.class), 
    76             com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.ORCL.getInstance().as(Equity.class)}, 
     74                new Stock[]{ 
     75            com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.IBM.getInstance().as(Stock.class), 
     76            com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.ORCL.getInstance().as(Stock.class)}, 
    7777                begin, end, 
    7878                "./test-data/Yahoo", "./log/Yahoo"); 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/amp2008/ZeroCostByFactorsPortfolioGeneratorTest.java

    r1366 r1495  
    3434import com.numericalmethod.algoquant.data.type.portfolio.weighting.RankWeighting; 
    3535import com.numericalmethod.algoquant.data.type.portfolio.weighting.ZeroCostWeighting; 
    36 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    3736import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     37import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3838import com.numericalmethod.algoquant.model.factormodel.amp2008.ZeroCostByFactorsPortfolioGenerator.GroupGranularity; 
    3939import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    … …  
    5252    public static final CompanyHistoryDB COMPANY_HISTORY_DB = TestMarketData.COMPANY_HISTORY_DB; 
    5353    private static final DateTime BASE_TIME = new DateTime(2002, 1, 1, 0, 0, TimeZoneUtils.HONG_KONG); 
    54     private static final ZeroCostWeighting<Equity> weighting = new RankWeighting<Equity>(); 
     54    private static final ZeroCostWeighting<Stock> weighting = new RankWeighting<Stock>(); 
    5555 
    5656    private class TrivialFactor implements Factor { 
    5757 
    5858        @Override 
    59         public double getFactorExposure(Equity equity, DateTime time, 
    60             RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     59        public double getFactorExposure(Stock stock, DateTime time, 
     60                                        RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    6161            return 0; 
    6262        } 
    … …  
    8282            Exchange.HKEX.getClosingTimeOnDate(BASE_TIME)); 
    8383 
    84         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
    85         Portfolio<Equity> portfolio = multiFactor.newPortfolio(equities); 
     84        Set<Stock> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
     85        Portfolio<Stock> portfolio = multiFactor.newPortfolio(equities); 
    8686 
    8787        assertTrue(PortfolioUtils.isNormalized(portfolio, 1e-6)); 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/backtest/AnnualizedSummaryBacktesterTest.java

    r1366 r1495  
    2727import com.numericalmethod.algoquant.data.historicaldata.compustat.TestMarketData; 
    2828import com.numericalmethod.algoquant.data.type.portfolio.Portfolio; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import com.numericalmethod.suanshu.number.DoubleUtils; 
    3131import java.util.Collections; 
    … …  
    4545        RandomAccessCache<MarketSnapshot> marketSnapshotCache = TestMarketData.getMarketSnapshotCache(); 
    4646        @SuppressWarnings("unchecked") 
    47         Equity equity = TestMarketData.COMPANY_HISTORY_DB.getCompanyHistory(STOCK_ID).getEquity(); 
    48         Portfolio<Equity> portfolio = new Portfolio<Equity>(Collections.singletonMap(equity, 1.)); 
     47        Stock stock = TestMarketData.COMPANY_HISTORY_DB.getCompanyHistory(STOCK_ID).getStock(); 
     48        Portfolio<Stock> portfolio = new Portfolio<Stock>(Collections.singletonMap(stock, 1.)); 
    4949 
    5050        AnnualizedSummaryBacktester backtest = new AnnualizedSummaryBacktester(marketSnapshotCache); 
    … …  
    5555        assertTrue(DoubleUtils.equal(dailyMarginalReturns.get(1), 0.050125, 1E-6)); 
    5656        assertTrue(DoubleUtils.equal(dailyMarginalReturns.get(2), 0.011933, 1E-6)); 
    57  
    5857 
    5958        double totalReturn = backtest.backtest(portfolio, TestMarketData.START_TIME, TestMarketData.END_TIME).returns; 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/backtest/IndexedPortfoliosAverageReturnsCalculatorTest.java

    r1492 r1495  
    3535import com.numericalmethod.algoquant.data.type.portfolio.Portfolio; 
    3636import com.numericalmethod.algoquant.data.type.portfolio.PortfolioUtils; 
    37 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     37import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3838import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3939import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    … …  
    4949public class IndexedPortfoliosAverageReturnsCalculatorTest { 
    5050 
    51     private static final Equity FOO = new Equity("Foo", Exchange.HKEX); 
    52     private static final Equity BAR = new Equity("Bar", Exchange.HKEX); 
     51    private static final Stock FOO = new Stock("Foo", Exchange.HKEX); 
     52    private static final Stock BAR = new Stock("Bar", Exchange.HKEX); 
    5353    private static final DateTime START_TIME = new DateTime(2003, 1, 1, 16, 0, TimeZoneUtils.HONG_KONG); 
    5454 
    … …  
    6565    @Test 
    6666    public void test_0010() { 
    67         Portfolio<Equity> portfolioFoo = PortfolioUtils.newEqualWeightedPortfolio(Collections.singleton(FOO)); 
    68         Portfolio<Equity> portfolioBar = PortfolioUtils.newEqualWeightedPortfolio(Collections.singleton(BAR)); 
     67        Portfolio<Stock> portfolioFoo = PortfolioUtils.newEqualWeightedPortfolio(Collections.singleton(FOO)); 
     68        Portfolio<Stock> portfolioBar = PortfolioUtils.newEqualWeightedPortfolio(Collections.singleton(BAR)); 
    6969 
    7070        RandomAccessCache<MarketSnapshot> marketSnapshotCache = generateTestMarketSnapshotCache(); 
    … …  
    7373        FactorRanks secondIndex = new FactorRanks(2); 
    7474 
    75         BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries = new BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>>(); 
     75        BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries = new BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>>(); 
    7676 
    77         List<IndexedPortfolio<FactorRanks, Equity>> indexedPortfolios1 = new ArrayList<IndexedPortfolio<FactorRanks, Equity>>(); 
    78         IndexedPortfolio<FactorRanks, Equity> fooPortfolio1 = new IndexedPortfolio<FactorRanks, Equity>(firstIndex, portfolioFoo); 
    79         IndexedPortfolio<FactorRanks, Equity> barPortfolio1 = new IndexedPortfolio<FactorRanks, Equity>(secondIndex, portfolioBar); 
     77        List<IndexedPortfolio<FactorRanks, Stock>> indexedPortfolios1 = new ArrayList<IndexedPortfolio<FactorRanks, Stock>>(); 
     78        IndexedPortfolio<FactorRanks, Stock> fooPortfolio1 = new IndexedPortfolio<FactorRanks, Stock>(firstIndex, portfolioFoo); 
     79        IndexedPortfolio<FactorRanks, Stock> barPortfolio1 = new IndexedPortfolio<FactorRanks, Stock>(secondIndex, portfolioBar); 
    8080        indexedPortfolios1.add(fooPortfolio1); 
    8181        indexedPortfolios1.add(barPortfolio1); 
    8282        portfoliosTimeSeries.add(START_TIME, indexedPortfolios1); 
    8383 
    84         List<IndexedPortfolio<FactorRanks, Equity>> indexedPortfolios2 = new ArrayList<IndexedPortfolio<FactorRanks, Equity>>(); 
    85         IndexedPortfolio<FactorRanks, Equity> fooPortfolio2 = new IndexedPortfolio<FactorRanks, Equity>(secondIndex, portfolioFoo); 
    86         IndexedPortfolio<FactorRanks, Equity> barPortfolio2 = new IndexedPortfolio<FactorRanks, Equity>(firstIndex, portfolioBar); 
     84        List<IndexedPortfolio<FactorRanks, Stock>> indexedPortfolios2 = new ArrayList<IndexedPortfolio<FactorRanks, Stock>>(); 
     85        IndexedPortfolio<FactorRanks, Stock> fooPortfolio2 = new IndexedPortfolio<FactorRanks, Stock>(secondIndex, portfolioFoo); 
     86        IndexedPortfolio<FactorRanks, Stock> barPortfolio2 = new IndexedPortfolio<FactorRanks, Stock>(firstIndex, portfolioBar); 
    8787        indexedPortfolios2.add(fooPortfolio2); 
    8888        indexedPortfolios2.add(barPortfolio2); 
    … …  
    9595        List<TimedEntry<PortfoliosSnapshot>> portfolioSnapshots = portfolioSnapshotsCalculator.computePortfolioStates(portfoliosTimeSeries, endDate); 
    9696 
    97         SequentialCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> avgReturnsCache = 
     97        SequentialCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> avgReturnsCache = 
    9898            IndexedPortfoliosAverageReturnsCalculator.computeAverageReturnsTimeSeries( 
    9999            portfoliosTimeSeries, portfolioSnapshots, endDate); 
    100100 
    101         Iterator<TimedEntry<Map<IndexedPortfolio<FactorRanks, Equity>, Double>>> it = avgReturnsCache.iterator(); 
     101        Iterator<TimedEntry<Map<IndexedPortfolio<FactorRanks, Stock>, Double>>> it = avgReturnsCache.iterator(); 
    102102        assertTrue(it.hasNext()); 
    103103 
    104         TimedEntry<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> entry1 = it.next(); 
     104        TimedEntry<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> entry1 = it.next(); 
    105105        assertEquals(START_TIME, entry1.getTime()); 
    106         Map<IndexedPortfolio<FactorRanks, Equity>, Double> avgReturns1 = entry1.getData(); 
     106        Map<IndexedPortfolio<FactorRanks, Stock>, Double> avgReturns1 = entry1.getData(); 
    107107        assertEquals(0.01, avgReturns1.get(fooPortfolio1), 1e-15); 
    108108        assertEquals(0., avgReturns1.get(barPortfolio1), 1e-15); 
    109109 
    110         TimedEntry<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> entry2 = it.next(); 
     110        TimedEntry<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> entry2 = it.next(); 
    111111        assertEquals(START_TIME.plusMonths(4), entry2.getTime()); 
    112         Map<IndexedPortfolio<FactorRanks, Equity>, Double> avgReturns2 = entry2.getData(); 
     112        Map<IndexedPortfolio<FactorRanks, Stock>, Double> avgReturns2 = entry2.getData(); 
    113113        assertEquals(0.01, avgReturns2.get(fooPortfolio2), 1e-15); 
    114114        assertEquals(0., avgReturns2.get(barPortfolio2), 1e-15); 
    … …  
    133133        profiles.add(new CompanyProfile() { 
    134134            @Override 
    135             public Equity getEquity() { 
     135            public Stock getStock() { 
    136136                return FOO; 
    137137            } 
    … …  
    153153        profiles.add(new CompanyProfile() { 
    154154            @Override 
    155             public Equity getEquity() { 
     155            public Stock getStock() { 
    156156                return BAR; 
    157157            } 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/backtest/PortfolioSnapshotsCalculatorTest.java

    r1366 r1495  
    3030import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    3131import com.numericalmethod.algoquant.data.type.portfolio.Portfolio; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     32import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3333import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    3434import java.util.ArrayList; 
    … …  
    5151            marketSnapshotCache, Period.months(1)); 
    5252 
    53         List<IndexedPortfolio<FactorRanks, Equity>> portfolioList = Collections.singletonList(new IndexedPortfolio<FactorRanks, Equity>(new FactorRanks(1), new Portfolio<Equity>())); 
     53        List<IndexedPortfolio<FactorRanks, Stock>> portfolioList = Collections.singletonList(new IndexedPortfolio<FactorRanks, Stock>(new FactorRanks(1), new Portfolio<Stock>())); 
    5454 
    55         BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries = new BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>>(); 
     55        BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries = new BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>>(); 
    5656        portfoliosTimeSeries.add(TestMarketData.START_TIME, portfolioList); 
    5757        DateTime endDate = TestMarketData.START_TIME.plusYears(2); 
    … …  
    6969            marketSnapshotCache, Period.months(1)); 
    7070 
    71         List<IndexedPortfolio<FactorRanks, Equity>> portfolioList = new ArrayList<IndexedPortfolio<FactorRanks, Equity>>(2); 
     71        List<IndexedPortfolio<FactorRanks, Stock>> portfolioList = new ArrayList<IndexedPortfolio<FactorRanks, Stock>>(2); 
    7272 
    7373        FactorRanks index1 = new FactorRanks(1); 
    7474        FactorRanks index2 = new FactorRanks(2); 
    7575 
    76         portfolioList.add(new IndexedPortfolio<FactorRanks, Equity>(index1, new Portfolio<Equity>())); 
    77         portfolioList.add(new IndexedPortfolio<FactorRanks, Equity>(index2, new Portfolio<Equity>())); 
     76        portfolioList.add(new IndexedPortfolio<FactorRanks, Stock>(index1, new Portfolio<Stock>())); 
     77        portfolioList.add(new IndexedPortfolio<FactorRanks, Stock>(index2, new Portfolio<Stock>())); 
    7878 
    79         BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries = new BufferCache<List<IndexedPortfolio<FactorRanks, Equity>>>(); 
     79        BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries = new BufferCache<List<IndexedPortfolio<FactorRanks, Stock>>>(); 
    8080        portfoliosTimeSeries.add(TestMarketData.START_TIME, portfolioList); 
    8181        portfoliosTimeSeries.add(TestMarketData.START_TIME.plusMonths(6), portfolioList); 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/portfolio/FactorRankingTest.java

    r1366 r1495  
    2525import com.numericalmethod.algoquant.data.equity.bucketing.Bucket; 
    2626import com.numericalmethod.algoquant.data.equity.bucketing.Bucketing; 
    27 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    2827import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    29 import com.numericalmethod.algoquant.model.factormodel.EquityFactorValues; 
    30 import com.numericalmethod.algoquant.model.factormodel.factor.Beta; 
    31 import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    32 import com.numericalmethod.algoquant.model.factormodel.factor.LogMarketCap; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
     29import com.numericalmethod.algoquant.model.factormodel.StockFactorValues; 
     30import com.numericalmethod.algoquant.model.factormodel.factor.*; 
    3331import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    3432import static com.numericalmethod.nmutils.collection.CollectionUtils.*; 
    … …  
    4442public class FactorRankingTest { 
    4543 
    46     private static final Set<Equity> equities = new HashSet<Equity>(); 
    47     private static EquityFactorValues factorValues; 
     44    private static final Set<Stock> stocks = new HashSet<Stock>(); 
     45    private static StockFactorValues factorValues; 
    4846    private static List<Factor> factors; 
    4947 
    5048    @BeforeClass 
    5149    public static void setUpClass() throws Exception { 
    52         factorValues = new EquityFactorValues(); 
     50        factorValues = new StockFactorValues(); 
    5351        Factor factor1 = new LogMarketCap(); // methods on factors never get executed 
    5452        Factor factor2 = new Beta(0); 
    5553        factors = Arrays.asList(new Factor[]{factor1, factor2}); 
    5654 
    57         Equity equity; 
    58         equity = new Equity("1", Exchange.HKEX); 
    59         factorValues.put(factor1, equity, 1.0); 
    60         factorValues.put(factor2, equity, -99.0); 
    61         equities.add(equity); 
    62  
    63         equity = new Equity("2", Exchange.HKEX); 
    64         factorValues.put(factor1, equity, 2.0); 
    65         factorValues.put(factor2, equity, 99.0); 
    66         equities.add(equity); 
    67  
    68         equity = new Equity("3", Exchange.HKEX); 
    69         factorValues.put(factor1, equity, 3.0); 
    70         factorValues.put(factor2, equity, -99.0); 
    71         equities.add(equity); 
    72  
    73         equity = new Equity("4", Exchange.HKEX); 
    74         factorValues.put(factor1, equity, 4.0); 
    75         factorValues.put(factor2, equity, 99.0); 
    76         equities.add(equity); 
    77  
    78         equity = new Equity("5", Exchange.HKEX); 
    79         factorValues.put(factor1, equity, 5.0); 
    80         factorValues.put(factor2, equity, -99.0); 
    81         equities.add(equity); 
    82  
    83         equity = new Equity("6", Exchange.HKEX); 
    84         factorValues.put(factor1, equity, 6.0); 
    85         factorValues.put(factor2, equity, 99.0); 
    86         equities.add(equity); 
    87  
    88         equity = new Equity("7", Exchange.HKEX); 
    89         factorValues.put(factor1, equity, 7.0); 
    90         factorValues.put(factor2, equity, -99.0); 
    91         equities.add(equity); 
    92  
    93         equity = new Equity("8", Exchange.HKEX); 
    94         factorValues.put(factor1, equity, 8.0); 
    95         factorValues.put(factor2, equity, 99.0); 
    96         equities.add(equity); 
    97  
    98         equity = new Equity("9", Exchange.HKEX); 
    99         factorValues.put(factor1, equity, 9.0); 
    100         factorValues.put(factor2, equity, -99.0); 
    101         equities.add(equity); 
    102  
    103         equity = new Equity("A", Exchange.HKEX); 
    104         factorValues.put(factor1, equity, 10.0); 
    105         factorValues.put(factor2, equity, 99.0); 
    106         equities.add(equity); 
     55        Stock stock; 
     56        stock = new Stock("1", Exchange.HKEX); 
     57        factorValues.put(factor1, stock, 1.0); 
     58        factorValues.put(factor2, stock, -99.0); 
     59        stocks.add(stock); 
     60 
     61        stock = new Stock("2", Exchange.HKEX); 
     62        factorValues.put(factor1, stock, 2.0); 
     63        factorValues.put(factor2, stock, 99.0); 
     64        stocks.add(stock); 
     65 
     66        stock = new Stock("3", Exchange.HKEX); 
     67        factorValues.put(factor1, stock, 3.0); 
     68        factorValues.put(factor2, stock, -99.0); 
     69        stocks.add(stock); 
     70 
     71        stock = new Stock("4", Exchange.HKEX); 
     72        factorValues.put(factor1, stock, 4.0); 
     73        factorValues.put(factor2, stock, 99.0); 
     74        stocks.add(stock); 
     75 
     76        stock = new Stock("5", Exchange.HKEX); 
     77        factorValues.put(factor1, stock, 5.0); 
     78        factorValues.put(factor2, stock, -99.0); 
     79        stocks.add(stock); 
     80 
     81        stock = new Stock("6", Exchange.HKEX); 
     82        factorValues.put(factor1, stock, 6.0); 
     83        factorValues.put(factor2, stock, 99.0); 
     84        stocks.add(stock); 
     85 
     86        stock = new Stock("7", Exchange.HKEX); 
     87        factorValues.put(factor1, stock, 7.0); 
     88        factorValues.put(factor2, stock, -99.0); 
     89        stocks.add(stock); 
     90 
     91        stock = new Stock("8", Exchange.HKEX); 
     92        factorValues.put(factor1, stock, 8.0); 
     93        factorValues.put(factor2, stock, 99.0); 
     94        stocks.add(stock); 
     95 
     96        stock = new Stock("9", Exchange.HKEX); 
     97        factorValues.put(factor1, stock, 9.0); 
     98        factorValues.put(factor2, stock, -99.0); 
     99        stocks.add(stock); 
     100 
     101        stock = new Stock("A", Exchange.HKEX); 
     102        factorValues.put(factor1, stock, 10.0); 
     103        factorValues.put(factor2, stock, 99.0); 
     104        stocks.add(stock); 
    107105    } 
    108106 
    … …  
    113111        factor2nBuckets.put(factors.get(1), 2); 
    114112        Bucketing<FactorRanks> bucketing = new FactorRanking(factors, factor2nBuckets, factorValues); 
    115         Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(equities); 
    116  
     113        Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(stocks); 
    117114 
    118115        assertEquals(6, buckets.size()); 
    … …  
    120117        Bucket<FactorRanks> bucket; 
    121118        bucket = buckets.get(new FactorRanks(1, 1));// [-∞, 3], [-∞, -99] 
    122         assertEquals(2, bucket.getEquitySet().size()); 
     119        assertEquals(2, bucket.getStocks().size()); 
    123120 
    124121        bucket = buckets.get(new FactorRanks(2, 1));// [4, 7], [-∞, -99] 
    125         assertEquals(2, bucket.getEquitySet().size()); 
     122        assertEquals(2, bucket.getStocks().size()); 
    126123 
    127124        bucket = buckets.get(new FactorRanks(3, 1));// [7, 10], [-∞, -99] 
    128         assertEquals(1, bucket.getEquitySet().size()); 
     125        assertEquals(1, bucket.getStocks().size()); 
    129126 
    130127        bucket = buckets.get(new FactorRanks(1, 2));// [-∞, 3], [99, ∞] 
    131         assertEquals(1, bucket.getEquitySet().size()); 
     128        assertEquals(1, bucket.getStocks().size()); 
    132129 
    133130        bucket = buckets.get(new FactorRanks(2, 2));// [-∞, 3], [99, ∞] 
    134         assertEquals(2, bucket.getEquitySet().size()); 
     131        assertEquals(2, bucket.getStocks().size()); 
    135132 
    136133        bucket = buckets.get(new FactorRanks(3, 2));// [-∞, 3], [99, ∞] 
    137         assertEquals(2, bucket.getEquitySet().size()); 
     134        assertEquals(2, bucket.getStocks().size()); 
    138135    } 
    139136 
    … …  
    144141        factor2nBuckets.put(factors.get(1), 1); 
    145142        Bucketing<FactorRanks> bucketing = new FactorRanking(factors, factor2nBuckets, factorValues); 
    146         Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(equities); 
    147  
     143        Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(stocks); 
    148144 
    149145        assertEquals(3, buckets.size()); 
    … …  
    151147        Bucket<FactorRanks> bucket; 
    152148        bucket = buckets.get(new FactorRanks(1, 1)); 
    153         assertEquals(3, bucket.getEquitySet().size()); 
     149        assertEquals(3, bucket.getStocks().size()); 
    154150 
    155151        bucket = buckets.get(new FactorRanks(2, 1)); 
    156         assertEquals(4, bucket.getEquitySet().size()); 
     152        assertEquals(4, bucket.getStocks().size()); 
    157153 
    158154        bucket = buckets.get(new FactorRanks(3, 1)); 
    159         assertEquals(3, bucket.getEquitySet().size()); 
     155        assertEquals(3, bucket.getStocks().size()); 
    160156    } 
    161157 
    … …  
    166162        factor2nBuckets.put(factors.get(1), 2); 
    167163        Bucketing<FactorRanks> bucketing = new FactorRanking(factors, factor2nBuckets, factorValues); 
    168         Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(equities); 
     164        Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(stocks); 
    169165 
    170166        Set<FactorRanks> keys = buckets.keySet(); 
    … …  
    187183        factor2nBuckets.put(factors.get(1), 1); 
    188184        Bucketing<FactorRanks> bucketing = new FactorRanking(factors, factor2nBuckets, factorValues); 
    189         Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(equities); 
     185        Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(stocks); 
    190186 
    191187        Set<FactorRanks> keys = buckets.keySet(); 
    … …  
    205201        factor2nBuckets.put(factors.get(1), 1); 
    206202        Bucketing<FactorRanks> bucketing = new FactorRanking(factors, factor2nBuckets, factorValues); 
    207         Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(equities); 
     203        Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(stocks); 
    208204 
    209205        Set<FactorRanks> keys = buckets.keySet(); 
    … …  
    221217        factor2nBuckets.put(factors.get(1), 1); 
    222218        Bucketing<FactorRanks> bucketing = new FactorRanking(factors, factor2nBuckets, factorValues); 
    223         Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(equities); 
     219        Map<FactorRanks, Bucket<FactorRanks>> buckets = bucketing.sort(stocks); 
    224220 
    225221        Set<FactorRanks> keys = buckets.keySet(); 
    … …  
    230226        assertEquals(expKeys, keys); 
    231227 
    232         assertEquals(10, buckets.get(new FactorRanks(1, 1)).getEquitySet().size()); 
     228        assertEquals(10, buckets.get(new FactorRanks(1, 1)).getStocks().size()); 
    233229    } 
    234230} 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/portfolio/PortfolioSeriesGeneratorTest.java

    r1366 r1495  
    3030import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    3131import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     32import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3333import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3434import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    35 import java.util.ArrayList; 
    36 import java.util.Collections; 
    37 import java.util.List; 
    38 import java.util.Set; 
     35import java.util.*; 
    3936import org.joda.time.Period; 
    4037import static org.junit.Assert.*; 
    … …  
    5855            Collections.singletonList(nBuckets)); 
    5956 
    60         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
    61         SequentialCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries = portfolioGenerator.generatePortfolios( 
     57        Set<Stock> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
     58        SequentialCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries = portfolioGenerator.generatePortfolios( 
    6259            equities, TestMarketData.START_TIME, 
    6360            TestMarketData.START_TIME.plus(STEP_SIZE), STEP_SIZE); 
    64         for (TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>> timedPortfolios : portfoliosTimeSeries) { 
     61        for (TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>> timedPortfolios : portfoliosTimeSeries) { 
    6562            assertEquals(equities.size(), numberOfEquitiesInPortfolios(timedPortfolios.getData())); 
    6663            assertTrue(preservesOrdering(timedPortfolios, factor, marketSnapshots)); 
    … …  
    6865    } 
    6966 
    70     private int numberOfEquitiesInPortfolios(List<IndexedPortfolio<FactorRanks, Equity>> portfolios) { 
     67    private int numberOfEquitiesInPortfolios(List<IndexedPortfolio<FactorRanks, Stock>> portfolios) { 
    7168        int number = 0; 
    72         for (IndexedPortfolio<FactorRanks, Equity> portfolio : portfolios) { 
     69        for (IndexedPortfolio<FactorRanks, Stock> portfolio : portfolios) { 
    7370            number += portfolio.getPortfolio().getWeights().size(); 
    7471        } 
    … …  
    7774 
    7875    private boolean preservesOrdering( 
    79         TimedEntry<List<IndexedPortfolio<FactorRanks, Equity>>> timedPortfolios, 
     76        TimedEntry<List<IndexedPortfolio<FactorRanks, Stock>>> timedPortfolios, 
    8077        Factor factor, 
    8178        RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    82         List<IndexedPortfolio<FactorRanks, Equity>> portfolios = timedPortfolios.getData(); 
     79        List<IndexedPortfolio<FactorRanks, Stock>> portfolios = timedPortfolios.getData(); 
    8380        List<Double> mins = new ArrayList<Double>(portfolios.size()); 
    8481        List<Double> maxs = new ArrayList<Double>(portfolios.size()); 
    8582 
    86         for (IndexedPortfolio<FactorRanks, Equity> portfolio : portfolios) { 
     83        for (IndexedPortfolio<FactorRanks, Stock> portfolio : portfolios) { 
    8784            double min = Double.POSITIVE_INFINITY; 
    8885            double max = Double.NEGATIVE_INFINITY; 
    89             for (Equity equity : portfolio.getPortfolio().getWeights().keySet()) { 
    90                 double factorValue = factor.getFactorExposure(equity, timedPortfolios.getTime(), marketSnapshotCache); 
     86            for (Stock stock : portfolio.getPortfolio().getWeights().keySet()) { 
     87                double factorValue = factor.getFactorExposure(stock, timedPortfolios.getTime(), marketSnapshotCache); 
    9188                min = Math.min(min, factorValue); 
    9289                max = Math.max(max, factorValue); 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/portfolio/RandomFactor.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    2727import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3030import java.util.Collections; 
    … …  
    3838 
    3939    @Override 
    40     public double getFactorExposure(Equity equity, DateTime time, 
    41         RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    42         return equity.getSymbol().hashCode() % (Math.pow(time.getYear(), 2) * Math.pow(time.getMonthOfYear(), 3)); 
     40    public double getFactorExposure(Stock stock, DateTime time, 
     41                                    RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     42        return stock.getSymbol().hashCode() % (Math.pow(time.getYear(), 2) * Math.pow(time.getMonthOfYear(), 3)); 
    4343    } 
    4444 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/FamaMacBethRegressionTest.java

    r1366 r1495  
    3030import com.numericalmethod.algoquant.data.historicaldata.compustat.TestMarketData; 
    3131import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     32import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3333import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3434import com.numericalmethod.algoquant.model.factormodel.factor.Intercept; 
    … …  
    5454 
    5555        @Override 
    56         public double getFactorExposure(Equity equity, DateTime time, 
    57             RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     56        public double getFactorExposure(Stock equity, DateTime time, 
     57                                        RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    5858            try { 
    5959                return getReturnForNextPeriod(marketSnapshotCache, equity, time, time.plus(period)); 
    … …  
    7979 
    8080        FamaMacBethRegression regression = new FamaMacBethRegression(marketSnapshots); 
    81         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
     81        Set<Stock> stocks = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
    8282 
    8383        Factor intercept = new Intercept(); 
    … …  
    8686 
    8787        FamaMacBethRegressionResults results = regression.run( 
    88             equities, 
     88            stocks, 
    8989            factors, 
    9090            TestMarketData.START_TIME, 
    … …  
    103103            double cheatingPremium = cheatingCoefficients.get(i); 
    104104            assertEquals("cheating factor completely explains the return", 1., cheatingPremium, 1e-10); 
    105             for (Equity equity : equities) { 
    106                 double cheatingExposure = returnFactor.getFactorExposure(equity, time, marketSnapshots); 
     105            for (Stock stock : stocks) { 
     106                double cheatingExposure = returnFactor.getFactorExposure(stock, time, marketSnapshots); 
    107107                double cheatingContribution = cheatingPremium * cheatingExposure; 
    108108                double returnFromRegression = cheatingContribution + interceptContribution; 
    109                 double actualReturn = getReturnForNextPeriod(marketSnapshots, equity, time, time.plus(Period.months(1))); 
     109                double actualReturn = getReturnForNextPeriod(marketSnapshots, stock, time, time.plus(Period.months(1))); 
    110110                assertEquals(actualReturn, returnFromRegression, 1e-15); 
    111111            } 
    … …  
    115115 
    116116    private static double getReturnForNextPeriod(RandomAccessCache<MarketSnapshot> cache, 
    117         Equity equity, DateTime startTime, DateTime endTime) { 
    118         double currPrice = cache.get(startTime).getData().getProfile(equity).getPrice(); 
    119         double nextPrice = cache.get(endTime).getData().getProfile(equity).getPrice(); 
     117                                                 Stock stock, DateTime startTime, DateTime endTime) { 
     118        double currPrice = cache.get(startTime).getData().getProfile(stock).getPrice(); 
     119        double nextPrice = cache.get(endTime).getData().getProfile(stock).getPrice(); 
    120120        return ReturnCalculators.SIMPLE.computeReturn(currPrice, nextPrice); 
    121121    } 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/capm/CAPMPerPortfolioTest.java

    r1366 r1495  
    3030import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    3131import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     32import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3333import com.numericalmethod.algoquant.model.factormodel.capm.CAPM; 
    3434import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    … …  
    3838import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.PortfolioSeriesGenerator; 
    3939import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.RandomFactor; 
    40 import java.util.ArrayList; 
    41 import java.util.Collections; 
    42 import java.util.List; 
    43 import java.util.Map; 
    44 import java.util.Set; 
     40import java.util.*; 
    4541import org.joda.time.DateTime; 
    4642import org.joda.time.Period; 
    … …  
    6460            Collections.singletonList(dimension)); 
    6561 
    66         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshotCache); 
     62        Set<Stock> stocks = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshotCache); 
    6763 
    68         SequentialCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries = 
     64        SequentialCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries = 
    6965            portfolioGenerator.generatePortfolios( 
    70             equities, 
    71             TestMarketData.START_TIME, 
    72             TestMarketData.END_TIME, 
    73             Period.months(12)); 
     66                stocks, 
     67                TestMarketData.START_TIME, 
     68                TestMarketData.END_TIME, 
     69                Period.months(12)); 
    7470 
    7571        PortfolioSnapshotsCalculator portfolioSnapshotsCalculator = new PortfolioSnapshotsCalculator( 
    … …  
    9086 
    9187        // Compare CAPM beta from monthly snapshot with fresh beta 
    92         for (Equity equity : equities) { 
     88        for (Stock stock : stocks) { 
    9389            for (TimedEntry<MarketSnapshot> timedSnapshot : monthlySnapshotsFromPortfolioStates) { 
    94                 double betaFromSnapshot = timedSnapshot.getData().getProfile(equity).getMeasureValue(new CAPMPerPortfolio.Beta()); 
    95                 FactorRanks index = findPortfolioIndicesOfEquityAtTime(equity, portfoliosStates, timedSnapshot.getTime()); 
     90                double betaFromSnapshot = timedSnapshot.getData().getProfile(stock).getMeasureValue(new CAPMPerPortfolio.Beta()); 
     91                FactorRanks index = findPortfolioIndicesOfStockAtTime(stock, portfoliosStates, timedSnapshot.getTime()); 
    9692                double freshBeta = indexedCAPM.get(index).beta(); 
    9793                assertEquals(freshBeta, betaFromSnapshot, 1e-15); 
    … …  
    10096    } 
    10197 
    102     private FactorRanks findPortfolioIndicesOfEquityAtTime( 
    103         Equity product, 
     98    private FactorRanks findPortfolioIndicesOfStockAtTime( 
     99        Stock product, 
    104100        List<TimedEntry<PortfoliosSnapshot>> portfoliosStates, 
    105101        DateTime time) { 
    106102        for (TimedEntry<PortfoliosSnapshot> portfolioState : portfoliosStates) { 
    107103            if (portfolioState.getTime().equals(time)) { 
    108                 for (IndexedPortfolio<FactorRanks, Equity> portfolio : portfolioState.getData().getPortfolios()) { 
    109                     for (Equity equity : portfolio.getPortfolio().getProducts()) { 
    110                         if (equity.getSymbol().equals(product.getSymbol())) { 
     104                for (IndexedPortfolio<FactorRanks, Stock> portfolio : portfolioState.getData().getPortfolios()) { 
     105                    for (Stock stock : portfolio.getPortfolio().getProducts()) { 
     106                        if (stock.getSymbol().equals(product.getSymbol())) { 
    111107                            return portfolio.getIndex(); 
    112108                        } 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/panel/FactorPanelRegressionTest.java

    r1477 r1495  
    2323package com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.panel; 
    2424 
    25 import com.numericalmethod.algoquant.data.cache.BufferCache; 
    26 import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    27 import com.numericalmethod.algoquant.data.cache.SequentialCache; 
     25import com.numericalmethod.algoquant.data.cache.*; 
    2826import com.numericalmethod.algoquant.data.calendar.TimeZoneUtils; 
    2927import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    3028import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    3129import com.numericalmethod.algoquant.data.historicaldata.compustat.TestMarketData; 
    32 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    3330import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    34 import com.numericalmethod.algoquant.model.factormodel.EquityFactorValues; 
     31import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3532import com.numericalmethod.algoquant.model.factormodel.FactorValueLookup; 
     33import com.numericalmethod.algoquant.model.factormodel.StockFactorValues; 
    3634import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3735import com.numericalmethod.nmutils.collection.CollectionUtils; 
    … …  
    4947 
    5048    private List<Factor> factors = new ArrayList<Factor>(); 
    51     private List<Equity> equities = new ArrayList<Equity>(); 
     49    private List<Stock> stocks = new ArrayList<Stock>(); 
    5250    private Map<DateTime, FactorValueLookup> lookups; 
    5351    private List<DateTime> times = new ArrayList<DateTime>(); 
    54     private SequentialCache<Map<Equity, Double>> returnCache; 
     52    private SequentialCache<Map<Stock, Double>> returnCache; 
    5553 
    5654    public FactorPanelRegressionTest() { 
    … …  
    5856        factors.add(new Factor() { 
    5957            @Override 
    60             public double getFactorExposure(Equity equity, DateTime time, 
    61                 RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    62                 return time.getDayOfMonth() + (int) equity.getSymbol().charAt(0); 
     58            public double getFactorExposure(Stock stock, DateTime time, 
     59                                            RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     60                return time.getDayOfMonth() + (int) stock.getSymbol().charAt(0); 
    6361            } 
    6462 
    … …  
    7674        factors.add(new Factor() { 
    7775            @Override 
    78             public double getFactorExposure(Equity equity, DateTime time, 
    79                 RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    80                 return time.getMonthOfYear() + (int) equity.getSymbol().charAt(0); 
     76            public double getFactorExposure(Stock stock, DateTime time, 
     77                                            RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     78                return time.getMonthOfYear() + (int) stock.getSymbol().charAt(0); 
    8179            } 
    8280 
    … …  
    9290        }); 
    9391 
    94         equities.add(new Equity("A", Exchange.HKEX)); 
    95         equities.add(new Equity("B", Exchange.HKEX)); 
     92        stocks.add(new Stock("A", Exchange.HKEX)); 
     93        stocks.add(new Stock("B", Exchange.HKEX)); 
    9694 
    9795        times.add(JodaTimeUtils.getDate(2001, 2, 1, TimeZoneUtils.HONG_KONG)); 
    … …  
    127125        for (DateTime time : times) { 
    128126 
    129             EquityFactorValues factorValues = new EquityFactorValues(); 
    130             for (Equity equity : equities) { 
     127            StockFactorValues factorValues = new StockFactorValues(); 
     128            for (Stock stock : stocks) { 
    131129                for (Factor factor : factors) { 
    132                     double factorValue = factor.getFactorExposure(equity, time, TestMarketData.getMarketSnapshotCache()); 
    133                     factorValues.put(factor, equity, factorValue); 
     130                    double factorValue = factor.getFactorExposure(stock, time, TestMarketData.getMarketSnapshotCache()); 
     131                    factorValues.put(factor, stock, factorValue); 
    134132                } 
    135133            } 
    … …  
    141139    } 
    142140 
    143     private SequentialCache<Map<Equity, Double>> getReturnCache() { 
     141    private SequentialCache<Map<Stock, Double>> getReturnCache() { 
    144142 
    145         BufferCache<Map<Equity, Double>> returnBufferCache = new BufferCache<Map<Equity, Double>>(); 
     143        BufferCache<Map<Stock, Double>> returnBufferCache = new BufferCache<Map<Stock, Double>>(); 
    146144 
    147         Map<Equity, Double> map1 = new HashMap<Equity, Double>(); 
    148         map1.put(equities.get(0), 1.0); 
    149         map1.put(equities.get(1), 2.0); 
     145        Map<Stock, Double> map1 = new HashMap<Stock, Double>(); 
     146        map1.put(stocks.get(0), 1.0); 
     147        map1.put(stocks.get(1), 2.0); 
    150148        returnBufferCache.add(times.get(0), map1); 
    151149 
    152         Map<Equity, Double> map2 = new HashMap<Equity, Double>(); 
    153         map2.put(equities.get(0), 3.0); 
    154         map2.put(equities.get(1), 4.0); 
     150        Map<Stock, Double> map2 = new HashMap<Stock, Double>(); 
     151        map2.put(stocks.get(0), 3.0); 
     152        map2.put(stocks.get(1), 4.0); 
    155153        returnBufferCache.add(times.get(1), map2); 
    156154 

  • core/src/test/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/panel/FamaMacBethPanelRegressionTest.java

    r1366 r1495  
    2828import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshotUtils; 
    2929import com.numericalmethod.algoquant.data.historicaldata.compustat.TestMarketData; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3131import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    3232import com.numericalmethod.algoquant.model.factormodel.factor.Intercept; 
    … …  
    5151 
    5252        @Override 
    53         public double getFactorExposure(Equity equity, DateTime time, 
    54             RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
     53        public double getFactorExposure(Stock stock, DateTime time, 
     54                                        RandomAccessCache<MarketSnapshot> marketSnapshotCache) { 
    5555            try { 
    56                 return getReturnForNextPeriod(marketSnapshotCache, equity, time, time.plus(period)); 
     56                return getReturnForNextPeriod(marketSnapshotCache, stock, time, time.plus(period)); 
    5757            } catch (Exception ex) { 
    5858                throw new RuntimeException(ex); 
    … …  
    7676 
    7777        FamaMacBethPanelRegression regression = new FamaMacBethPanelRegression(marketSnapshots); 
    78         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
     78        Set<Stock> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
    7979 
    8080        Factor intercept = new Intercept(); 
    … …  
    9595 
    9696    private static double getReturnForNextPeriod(RandomAccessCache<MarketSnapshot> cache, 
    97         Equity equity, DateTime startTime, DateTime endTime) { 
    98         double currPrice = cache.get(startTime).getData().getProfile(equity).getPrice(); 
    99         double nextPrice = cache.get(endTime).getData().getProfile(equity).getPrice(); 
     97                                                 Stock stock, DateTime startTime, DateTime endTime) { 
     98        double currPrice = cache.get(startTime).getData().getProfile(stock).getPrice(); 
     99        double nextPrice = cache.get(endTime).getData().getProfile(stock).getPrice(); 
    100100        return ReturnCalculators.SIMPLE.computeReturn(currPrice, nextPrice); 
    101101    } 

  • core/src/test/java/com/numericalmethod/algoquant/model/volarb/MeanReversionStrategyTest.java

    r1432 r1495  
    3232import com.numericalmethod.algoquant.execution.performance.measure.ExchangeRateTable; 
    3333import com.numericalmethod.algoquant.execution.performance.measure.SimpleExchangeRateTable; 
    34 import com.numericalmethod.algoquant.execution.product.Basket; 
    35 import com.numericalmethod.algoquant.execution.product.BasketUtils; 
    36 import com.numericalmethod.algoquant.execution.product.Currencies; 
    37 import com.numericalmethod.algoquant.execution.product.Product; 
    38 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     34import com.numericalmethod.algoquant.execution.product.*; 
     35import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3936import com.numericalmethod.algoquant.execution.product.equity.usa.nyse.NYSEProduct; 
    40 import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    41 import com.numericalmethod.algoquant.execution.simulator.SimpleSimulator; 
    42 import com.numericalmethod.algoquant.execution.simulator.Simulator; 
     37import com.numericalmethod.algoquant.execution.simulator.*; 
    4338import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    4439import java.util.*; 
    … …  
    5853 
    5954        Product productXOM = new NYSEProduct("XOM"); 
    60         Equity equityProductXOM = productXOM.as(Equity.class); 
     55        Stock stockProductXOM = productXOM.as(Stock.class); 
    6156 
    6257        Product productGOOG = new NYSEProduct("GOOG"); 
    63         Equity equityProductGOOG = productGOOG.as(Equity.class); 
     58        Stock stockProductGOOG = productGOOG.as(Stock.class); 
    6459 
    6560        // simulation period 
    … …  
    7065 
    7166        YahooEOD yahooEODXOM = new YahooEOD( 
    72             equityProductXOM, 
     67            stockProductXOM, 
    7368            "./test-data/Yahoo"); 
    7469 
    7570        YahooEOD yahooEODGOOG = new YahooEOD( 
    76             equityProductGOOG, 
     71            stockProductGOOG, 
    7772            "./test-data/Yahoo"); 
    7873 
    … …  
    8075        DepthCaches depthCaches = new DepthCaches(); 
    8176        depthCaches.addCache(productXOM, 
    82                              DepthCacheUtils.fromEquityEODCache(productXOM, yahooEODXOM.getCache(begin, end))); 
     77                             DepthCacheUtils.fromStockEODCache(productXOM, yahooEODXOM.getCache(begin, end))); 
    8378        depthCaches.addCache(productGOOG, 
    84                              DepthCacheUtils.fromEquityEODCache(productGOOG, yahooEODGOOG.getCache(begin, end))); 
     79                             DepthCacheUtils.fromStockEODCache(productGOOG, yahooEODGOOG.getCache(begin, end))); 
    8580 
    8681        // create the strategy 
    … …  
    9186            1e6, // scale 
    9287            1 // lot size 
    93             ); 
     88        ); 
    9489 
    9590        Simulator simulator = new SimpleSimulator.Builder(depthCaches).useExchangeRates(rates).withSynchronizedDepthUpdates().build(); 

  • demo/src/main/java/com/numericalmethod/algoquant/execution/simulation/batch/sensitivity/demo/DemoSensitivityAnalyzer.java

    r1464 r1495  
    2727import com.numericalmethod.algoquant.execution.performance.measure.*; 
    2828import com.numericalmethod.algoquant.execution.product.Product; 
    29 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     29import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3030import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    3131import com.numericalmethod.algoquant.execution.simulation.batch.BatchSimulation.SimulationException; 
    … …  
    6262    // Simulation parameters 
    6363    private static final Product PRODUCT = HSI.getInstance(); 
    64     private static final Equity EQUITY = PRODUCT.as(Equity.class); 
    65     private static final DateTime BEGIN = JodaTimeUtils.getDate(2008, 1, 1, EQUITY.getExchange().timeZone); 
     64    private static final Stock STOCK = PRODUCT.as(Stock.class); 
     65    private static final DateTime BEGIN = JodaTimeUtils.getDate(2008, 1, 1, STOCK.getExchange().timeZone); 
    6666    private static final DateTime END = BEGIN.plusYears(1); 
    6767    private static final StrategyFactory<Strategy, Vector> STRATEGY_FACTORY = 
    6868        new StrategyFactory<Strategy, Vector>() { 
    69         @Override 
    70         public Strategy newStrategy(Vector lags) { 
    71             ProductParams param = new ProductParams(PRODUCT, 1); 
    72             return new SMA2Crossover(param, (int) lags.get(1), (int) lags.get(2)); 
    73         } 
    74     }; 
     69            @Override 
     70            public Strategy newStrategy(Vector lags) { 
     71                ProductParams param = new ProductParams(PRODUCT, 1); 
     72                return new SMA2Crossover(param, (int) lags.get(1), (int) lags.get(2)); 
     73            } 
     74        }; 
    7575 
    7676    public static void main(String[] args) throws SimulationException { 

  • demo/src/main/java/com/numericalmethod/algoquant/execution/strategy/demo/DemoTimer.java

    r1438 r1495  
    3030import com.numericalmethod.algoquant.execution.component.chart.plotter.SimpleStrategyPlotter; 
    3131import com.numericalmethod.algoquant.execution.component.tradeblotter.TradeBlotter; 
    32 import com.numericalmethod.algoquant.execution.performance.measure.ExchangeRateTable; 
    33 import com.numericalmethod.algoquant.execution.performance.measure.ProfitLoss; 
    34 import com.numericalmethod.algoquant.execution.performance.measure.SimpleExchangeRateTable; 
     32import com.numericalmethod.algoquant.execution.performance.measure.*; 
    3533import com.numericalmethod.algoquant.execution.performance.measure.ir.InformationRatioByPeriod; 
    3634import com.numericalmethod.algoquant.execution.performance.measure.omega.OmegaByPeriod; 
    3735import com.numericalmethod.algoquant.execution.performance.measure.omega.OmegaFromSummation; 
    3836import com.numericalmethod.algoquant.execution.product.Product; 
    39 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     37import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4038import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    41 import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    42 import com.numericalmethod.algoquant.execution.simulator.SimpleSimulator; 
    43 import com.numericalmethod.algoquant.execution.simulator.Simulator; 
     39import com.numericalmethod.algoquant.execution.simulator.*; 
    4440import com.numericalmethod.algoquant.execution.simulator.subscription.Subscribable; 
    4541import com.numericalmethod.algoquant.execution.simulator.subscription.timer.SimulationTimer; 
    … …  
    4945import static com.numericalmethod.nmutils.NMUtils.getClassLogger; 
    5046import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    51 import java.util.Collection; 
    52 import java.util.Collections; 
    53 import java.util.List; 
    54 import org.joda.time.DateTime; 
    55 import org.joda.time.Days; 
    56 import org.joda.time.MonthDay; 
    57 import org.joda.time.Period; 
     47import java.util.*; 
     48import org.joda.time.*; 
    5849import org.slf4j.Logger; 
    5950 
    … …  
    6960    private static final Logger LOGGER = getClassLogger(); 
    7061    private static final Product PRODUCT = HSI.getInstance(); 
    71     private static final Equity EQUITY = PRODUCT.as(Equity.class); 
     62    private static final Stock STOCK = PRODUCT.as(Stock.class); 
    7263    private static final ProductParams PARAMS = new ProductParams(PRODUCT, 1.0); 
    7364    private static final DateTime BEGIN = 
    74         JodaTimeUtils.getDate(2000, 1, 1, EQUITY.getExchange().timeZone); 
     65        JodaTimeUtils.getDate(2000, 1, 1, STOCK.getExchange().timeZone); 
    7566    private static final DateTime END = 
    76         JodaTimeUtils.getDate(2012, 2, 1, EQUITY.getExchange().timeZone); 
     67        JodaTimeUtils.getDate(2012, 2, 1, STOCK.getExchange().timeZone); 
    7768    private static final MonthDay BUY_DATE = new MonthDay(12, 29); 
    7869    private static final MonthDay SELL_DATE = new MonthDay(1, 6); 

  • demo/src/main/java/com/numericalmethod/algoquant/execution/strategy/demo/DemoTutorialStrategy.java

    r1438 r1495  
    3131import com.numericalmethod.algoquant.execution.component.chart.plotter.SimpleStrategyPlotter; 
    3232import com.numericalmethod.algoquant.execution.component.tradeblotter.TradeBlotter; 
    33 import com.numericalmethod.algoquant.execution.performance.measure.ExchangeRateTable; 
    34 import com.numericalmethod.algoquant.execution.performance.measure.ProfitLoss; 
    35 import com.numericalmethod.algoquant.execution.performance.measure.SimpleExchangeRateTable; 
     33import com.numericalmethod.algoquant.execution.performance.measure.*; 
    3634import com.numericalmethod.algoquant.execution.performance.measure.ir.InformationRatioByPeriod; 
    3735import com.numericalmethod.algoquant.execution.performance.measure.omega.OmegaByPeriod; 
    … …  
    3937import com.numericalmethod.algoquant.execution.product.Currencies; 
    4038import com.numericalmethod.algoquant.execution.product.Product; 
    41 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     39import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4240import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    43 import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    44 import com.numericalmethod.algoquant.execution.simulator.SimpleSimulator; 
    45 import com.numericalmethod.algoquant.execution.simulator.Simulator; 
     41import com.numericalmethod.algoquant.execution.simulator.*; 
    4642import com.numericalmethod.algoquant.execution.strategy.ProductParams; 
    4743import com.numericalmethod.algoquant.execution.strategy.Strategy; 
    … …  
    6864    public static void main(String[] args) { 
    6965        Product product = HSI.getInstance(); 
    70         Equity equity = product.as(Equity.class); 
     66        Stock stock = product.as(Stock.class); 
    7167        ProductParams params = new ProductParams(product, 1.0); 
    7268 
    73         DateTime begin = JodaTimeUtils.getDate(2000, 1, 1, equity.getExchange().timeZone); 
    74         DateTime end = JodaTimeUtils.getDate(2012, 1, 1, equity.getExchange().timeZone); 
     69        DateTime begin = JodaTimeUtils.getDate(2000, 1, 1, stock.getExchange().timeZone); 
     70        DateTime end = JodaTimeUtils.getDate(2012, 1, 1, stock.getExchange().timeZone); 
    7571 
    7672        SequentialCache<Depth> dailyData = DataSources.YAHOO.forProduct(product).getCache(begin, end); 

  • demo/src/main/java/com/numericalmethod/algoquant/model/corvalan2005/demo/DemoCorvalan2005.java

    r1475 r1495  
    115115    public static void main(String[] args) throws Exception { 
    116116        /* list the products to be traded */ 
    117         List<Product> products = ProductUtils.newEquityProductList( 
     117        List<Product> products = ProductUtils.newStockProductList( 
    118118            new String[]{ 
    119119            "ORCL", "GOOG", "AMZN", "IBM", "MSFT"}, 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/amp2008/demo/AMP2008DemoUtils.java

    r1492 r1495  
    2828import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshotUtils; 
    2929import com.numericalmethod.algoquant.data.historicaldata.compustat.CompanyHistoryDB; 
    30 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     30import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3131import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3232import java.util.ArrayList; 
    … …  
    5252    } 
    5353 
    54     public static Set<Equity> getEquitiesForPortfolios( 
     54    public static Set<Stock> getEquitiesForPortfolios( 
    5555        RandomAccessCache<MarketSnapshot> marketSnapshots, 
    5656        DateTime factorFirstRequiredDate, 
    5757        DateTime currentTime, 
    5858        DateTime endTime) { 
    59         Set<Equity> allEquities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
    60         Set<Equity> liquidEquities = new LiquidityFilter( 
     59        Set<Stock> allEquities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
     60        Set<Stock> liquidEquities = new LiquidityFilter( 
    6161            currentTime.minusMonths(LIQUIDITY_FIRST_DATE_OFFSET), 
    6262            currentTime, MIN_MCAP, MIN_PRICE).getFilteredEquities(marketSnapshots, allEquities); 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/amp2008/demo/DemoMultiFactor.java

    r1492 r1495  
    3939import com.numericalmethod.algoquant.data.type.portfolio.weighting.TopBottomQuantilesEqualWeighting; 
    4040import com.numericalmethod.algoquant.data.type.portfolio.weighting.ZeroCostWeighting; 
    41 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     41import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4242import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    4343import com.numericalmethod.algoquant.model.factormodel.amp2008.*; 
    … …  
    9595                Collections.synchronizedList(new ArrayList<TimedEntry<CombinedLongShortResult>>()); 
    9696 
    97         final ZeroCostWeighting<Equity> weighting = new TopBottomQuantilesEqualWeighting<Equity>(5); 
     97        final ZeroCostWeighting<Stock> weighting = new TopBottomQuantilesEqualWeighting<Stock>(5); 
    9898 
    9999        List<DateTime> dates = getDatesForPortfolioFormation(BASE_DATE, PORTFOLIO_LIFETIME_IN_MONTHS, STEP_SIZE_IN_MONTHS, SIMULATION_END_DATE); 
    … …  
    121121                    DateTime endTime = currentTime.plusMonths(PORTFOLIO_LIFETIME_IN_MONTHS); 
    122122 
    123                     Set<Equity> equitiesForPortfolios = getEquitiesForPortfolios( 
     123                    Set<Stock> equitiesForPortfolios = getEquitiesForPortfolios( 
    124124                            marketSnapshotCache, factorFirstRequiredDate, currentTime, endTime); 
    125125 
    … …  
    127127                                              equitiesForPortfolios.size())); 
    128128 
    129                     Portfolio<Equity> portfolio = generatorBuilder.forFactor(factor, exchange.getClosingTimeOnDate(currentTime)). 
     129                    Portfolio<Stock> portfolio = generatorBuilder.forFactor(factor, exchange.getClosingTimeOnDate(currentTime)). 
    130130                            newPortfolio(equitiesForPortfolios); 
    131131 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/amp2008/demo/DemoMultiFactorTiming.java

    r1492 r1495  
    3939import com.numericalmethod.algoquant.data.type.portfolio.weighting.RankWeighting; 
    4040import com.numericalmethod.algoquant.data.type.portfolio.weighting.ZeroCostWeighting; 
    41 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     41import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4242import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    4343import com.numericalmethod.algoquant.model.factormodel.amp2008.CombinedLongShortResult; 
    … …  
    9393        final SequentialCache<Double> rates = new HKIBOR(HKMA_RATES_FILE_PATH).getRatesForMaturity(HKIBOR.Maturity.TWELVE_MONTH); 
    9494 
    95         final ZeroCostWeighting<Equity> weighting = new RankWeighting<Equity>(); 
     95        final ZeroCostWeighting<Stock> weighting = new RankWeighting<Stock>(); 
    9696 
    9797        Set<CompanyMeasure> requiredMeasures = FactorUtils.getRequiredMeasures(factors); 
    … …  
    133133                        DateTime endTime = currentTime.plusMonths(portfolioLifeTimeFinal); 
    134134 
    135                         Set<Equity> equitiesForPortfolios = getEquitiesForPortfolios( 
     135                        Set<Stock> equitiesForPortfolios = getEquitiesForPortfolios( 
    136136                            marketSnapshotCache, factorFirstRequiredDate, currentTime, endTime); 
    137137                        LOGGER.info(String.format("number of companies available for analysis: %d", 
    … …  
    141141                        DateTime endDate = exchange.getClosingTimeOnDate(endTime); 
    142142 
    143                         Portfolio<Equity> bmPortfolio = generatorBuilder.forFactor(bmFactor, beginDate). 
     143                        Portfolio<Stock> bmPortfolio = generatorBuilder.forFactor(bmFactor, beginDate). 
    144144                            newPortfolio(equitiesForPortfolios); 
    145145 
    146                         Portfolio<Equity> momentumPortfolio = generatorBuilder.forFactor(momentumFactor, beginDate). 
     146                        Portfolio<Stock> momentumPortfolio = generatorBuilder.forFactor(momentumFactor, beginDate). 
    147147                            newPortfolio(equitiesForPortfolios); 
    148148 
    149149                        @SuppressWarnings("unchecked") 
    150                         Portfolio<Equity> combinedPortfolio = combine(bmPortfolio, momentumPortfolio); 
     150                        Portfolio<Stock> combinedPortfolio = combine(bmPortfolio, momentumPortfolio); 
    151151 
    152152                        System.out.println(currentTime + ": " + combinedPortfolio); 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/demo/DemoFamaFrench1992.java

    r1492 r1495  
    2424 
    2525import com.numericalmethod.algoquant.annotation.Demo; 
    26 import com.numericalmethod.algoquant.data.cache.BufferCache; 
    27 import com.numericalmethod.algoquant.data.cache.RandomAccessCache; 
    28 import com.numericalmethod.algoquant.data.cache.SequentialCache; 
     26import com.numericalmethod.algoquant.data.cache.*; 
    2927import com.numericalmethod.algoquant.data.calendar.TimeZoneUtils; 
    3028import com.numericalmethod.algoquant.data.equity.CompanyHistory; 
     29import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CommonHistoryFilter; 
    3130import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    32 import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CommonHistoryFilter; 
    3331import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    3432import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshotUtils; 
    … …  
    3735import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    3836import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    39 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    40 import com.numericalmethod.algoquant.model.factormodel.factor.Beta; 
    41 import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    42 import com.numericalmethod.algoquant.model.factormodel.factor.FactorUtils; 
     37import com.numericalmethod.algoquant.execution.product.equity.Stock; 
     38import com.numericalmethod.algoquant.model.factormodel.factor.*; 
    4339import static com.numericalmethod.algoquant.model.factormodel.factor.FactorUtils.getEarliestBusinessDateBefore; 
    44 import com.numericalmethod.algoquant.model.factormodel.factor.Intercept; 
    45 import com.numericalmethod.algoquant.model.factormodel.factor.LogMarketCap; 
    46 import com.numericalmethod.algoquant.model.factormodel.famafrench1992.backtest.IndexedPortfoliosAverageReturnsCalculator; 
    47 import com.numericalmethod.algoquant.model.factormodel.famafrench1992.backtest.PortfolioSnapshotsCalculator; 
    48 import com.numericalmethod.algoquant.model.factormodel.famafrench1992.backtest.PortfoliosSnapshot; 
     40import com.numericalmethod.algoquant.model.factormodel.famafrench1992.backtest.*; 
    4941import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.FactorRanking.FactorRanks; 
    5042import com.numericalmethod.algoquant.model.factormodel.famafrench1992.portfolio.PortfolioSeriesGenerator; 
    51 import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.FamaMacBethRegression; 
    52 import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.FamaMacBethRegressionResults; 
    53 import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.RegressionCoefficientsCsvWriter; 
     43import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.*; 
    5444import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.capm.CAPMPerPortfolio; 
    5545import static com.numericalmethod.nmutils.NMUtils.*; 
    5646import java.io.IOException; 
    5747import java.text.ParseException; 
    58 import java.util.Arrays; 
    59 import java.util.List; 
    60 import java.util.Map; 
    61 import java.util.Set; 
     48import java.util.*; 
    6249import java.util.zip.ZipException; 
    6350import org.joda.time.DateTime; 
    … …  
    8774    private static final DateTime START_TIME = new DateTime(2003, 1, 1, 16, 0, TimeZoneUtils.HONG_KONG); 
    8875    private static final DateTime END_TIME = new DateTime(2011, 1, 1, 16, 0, TimeZoneUtils.HONG_KONG).plusWeeks(2); // TODO: due to Jan 1 holiday? hack again! 
    89     /* Every STEP_SIZE we form a new portfolio. */ 
     76    // Every STEP_SIZE we form a new portfolio. 
    9077    private static final Period PORTFOLIO_LIFETIME = Period.months(12); 
    9178    private static final String CROSSSECTION_OUTPUT_FILENAME = "./log/FamaCrossSectionalRegressionCoefficients.csv.zip"; 
    9279 
    9380    public static void main(String[] args) throws ZipException, IOException, ParseException { 
    94  
    9581        List<Factor> preRankingFactors = Arrays.asList( 
    9682            new LogMarketCap(), 
    … …  
    10793        List<CompanyHistory> histories = FamaFrench1992DemoUtils.COMPANY_HISTORY_DB.getAllCompanyHistories(); 
    10894 
    109         histories = new CommonHistoryFilter( 
    110             requiredMeasures, 
    111             earliestRequiredDate, 
    112             END_TIME).filter(histories); 
     95        histories = new CommonHistoryFilter(requiredMeasures, earliestRequiredDate, END_TIME).filter(histories); 
    11396 
    11497        RandomAccessCache<MarketSnapshot> fullPeriodDailyCache = MarketSnapshotUtils.newCache(histories, marketSeries, rates); 
    115         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(fullPeriodDailyCache); 
     98        Set<Stock> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(fullPeriodDailyCache); 
    11699 
    117100        LOGGER.info(String.format("number of companies available for analysis: %d", equities.size())); 
    … …  
    123106            preRankingFactors, 
    124107            nBucketsPerFactor // no. of buckets for each factors 
    125             ); 
     108        ); 
    126109 
    127         SequentialCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries = 
     110        SequentialCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries = 
    128111            portfolioGenerator.generatePortfolios( 
    129             equities, earliestRequiredDate, END_TIME, PORTFOLIO_LIFETIME); 
     112                equities, earliestRequiredDate, END_TIME, PORTFOLIO_LIFETIME); 
    130113 
    131114        // Calculate and write to file the portfolio's returns 
    … …  
    136119            portfolioSnapshotsCalculator.computePortfolioStates(portfoliosTimeSeries, END_TIME); // compute portfolios' returns 
    137120 
    138         SequentialCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> averageReturnsCache = 
     121        SequentialCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> averageReturnsCache = 
    139122            IndexedPortfoliosAverageReturnsCalculator.computeAverageReturnsTimeSeries(portfoliosTimeSeries, fullPeriodPortfoliosSnapshots, END_TIME); 
    140123 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/demo/DemoPartitioningByFactors.java

    r1492 r1495  
    3636import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    3737import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    38 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     38import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3939import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    4040import com.numericalmethod.algoquant.model.factormodel.factor.FactorUtils; 
    … …  
    9393 
    9494        RandomAccessCache<MarketSnapshot> fullPeriodDailyCache = newCache(histories, market, rates); 
    95         Set<Equity> equities = getEquitiesFromFirstSnapshot(fullPeriodDailyCache); 
     95        Set<Stock> equities = getEquitiesFromFirstSnapshot(fullPeriodDailyCache); 
    9696 
    9797        LOGGER.info(String.format("number of companies available for analysis: %d", equities.size())); 
    … …  
    104104            nBucketsPerFactor); 
    105105 
    106         SequentialCache<List<IndexedPortfolio<FactorRanks, Equity>>> portfoliosTimeSeries = 
     106        SequentialCache<List<IndexedPortfolio<FactorRanks, Stock>>> portfoliosTimeSeries = 
    107107            portfolioGenerator.generatePortfolios( 
    108108            equities, START_TIME, END_TIME, STEP_SIZE); 
    … …  
    115115            portfolioSnapshotsCalculator.computePortfolioStates(portfoliosTimeSeries, END_TIME); 
    116116 
    117         SequentialCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> averageReturnsCache = 
     117        SequentialCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> averageReturnsCache = 
    118118            IndexedPortfoliosAverageReturnsCalculator.computeAverageReturnsTimeSeries(portfoliosTimeSeries, fullPeriodPortfoliosSnapshots, END_TIME); 
    119119 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/famafrench1992/demo/FamaFrench1992DemoUtils.java

    r1366 r1495  
    2626import com.numericalmethod.algoquant.data.historicaldata.compustat.CompanyHistoryDB; 
    2727import com.numericalmethod.algoquant.data.type.portfolio.IndexedPortfolio; 
    28 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     28import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    2929import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
    3030import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    … …  
    5151 
    5252    public static void writePortfolioReturnsToFile( 
    53         SequentialCache<Map<IndexedPortfolio<FactorRanks, Equity>, Double>> returnsTimeSeries, 
     53        SequentialCache<Map<IndexedPortfolio<FactorRanks, Stock>, Double>> returnsTimeSeries, 
    5454        List<Factor> preRankingFactors, 
    5555        List<Integer> factorDimensions) 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/demo/DemoFamaMacBethRegression.java

    r1492 r1495  
    3030import com.numericalmethod.algoquant.data.calendar.TimeZoneUtils; 
    3131import com.numericalmethod.algoquant.data.equity.CompanyHistory; 
     32import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CommonHistoryFilter; 
    3233import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
    33 import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CommonHistoryFilter; 
    3434import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    3535import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshotUtils; 
    … …  
    3737import com.numericalmethod.algoquant.data.historicaldata.hkma.HKIBOR; 
    3838import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    39 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     39import com.numericalmethod.algoquant.data.type.StockEOD; 
    4040import com.numericalmethod.algoquant.execution.product.Product; 
    41 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    4241import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     42import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4343import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    44 import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    45 import com.numericalmethod.algoquant.model.factormodel.factor.FactorUtils; 
    46 import com.numericalmethod.algoquant.model.factormodel.factor.Intercept; 
    47 import com.numericalmethod.algoquant.model.factormodel.factor.LogMarketCap; 
    48 import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.FamaMacBethRegression; 
    49 import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.FamaMacBethRegressionResults; 
    50 import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.RegressionCoefficientsCsvWriter; 
     44import com.numericalmethod.algoquant.model.factormodel.factor.*; 
     45import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.*; 
    5146import static com.numericalmethod.nmutils.NMUtils.getClassLogger; 
    5247import com.numericalmethod.suanshu.misc.datastructure.time.JodaTimeUtils; 
    5348import java.io.IOException; 
    5449import java.text.ParseException; 
    55 import java.util.Arrays; 
    56 import java.util.List; 
    57 import java.util.Set; 
     50import java.util.*; 
    5851import java.util.zip.ZipException; 
    5952import org.joda.time.DateTime; 
    … …  
    134127 
    135128        RandomAccessCache<MarketSnapshot> marketSnapshots = MarketSnapshotUtils.newCache(histories, market, rates); 
    136         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
     129        Set<Stock> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
    137130 
    138131        LOGGER.info(String.format("number of companies available for analysis: %d", equities.size())); 
    … …  
    147140    private SequentialCache<Double> getHSIData(DateTime startDate, DateTime endDate) { 
    148141        Product HSIProduct = HSI.getInstance(); 
    149         Equity equityProduct = HSIProduct.as(Equity.class); 
     142        Stock stockProduct = HSIProduct.as(Stock.class); 
    150143 
    151         YahooEOD eod = new YahooEOD(equityProduct, "./log/HSI", "./log/HSI"); 
     144        YahooEOD eod = new YahooEOD(stockProduct, "./log/HSI", "./log/HSI"); 
    152145 
    153         DoubleEntryTransformer<EquityEOD> transformer = DoubleEntryTransformers.EQUITYEOD; 
     146        DoubleEntryTransformer<StockEOD> transformer = DoubleEntryTransformers.STOCK_EOD; 
    154147 
    155148        return transformer.doProcess(eod.getCache(startDate.minusWeeks(1), endDate));  // TODO: remove this hack by fixing getCache() 

  • demo/src/main/java/com/numericalmethod/algoquant/model/factormodel/regression/famamacbeth/panel/demo/DemoFamaMacBethPanelRegression.java

    r1492 r1495  
    3030import com.numericalmethod.algoquant.data.calendar.TimeZoneUtils; 
    3131import com.numericalmethod.algoquant.data.equity.CompanyHistory; 
     32import com.numericalmethod.algoquant.data.equity.filter.companyhistories.*; 
    3233import com.numericalmethod.algoquant.data.equity.measure.CompanyMeasure; 
     34import static com.numericalmethod.algoquant.data.equity.measure.CompanyMeasureCalculatorUtils.Mean; 
    3335import com.numericalmethod.algoquant.data.equity.measure.MarketCap; 
    34 import static com.numericalmethod.algoquant.data.equity.measure.CompanyMeasureCalculatorUtils.Mean; 
    35 import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CompanyMeasureFilter; 
    36 import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CommonHistoryFilter; 
    37 import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CompanyHistoriesFilter; 
    38 import com.numericalmethod.algoquant.data.equity.filter.companyhistories.CompositeFilter; 
    3936import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshot; 
    4037import com.numericalmethod.algoquant.data.equity.snapshot.MarketSnapshotUtils; 
    … …  
    4239import com.numericalmethod.algoquant.data.historicaldata.hkma.HKIBOR; 
    4340import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    44 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    45 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     41import com.numericalmethod.algoquant.data.type.StockEOD; 
    4642import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     43import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4744import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    48 import com.numericalmethod.algoquant.model.factormodel.factor.Factor; 
    49 import com.numericalmethod.algoquant.model.factormodel.factor.FactorUtils; 
    50 import com.numericalmethod.algoquant.model.factormodel.factor.Intercept; 
    51 import com.numericalmethod.algoquant.model.factormodel.factor.LogMarketCap; 
     45import com.numericalmethod.algoquant.model.factormodel.factor.*; 
    5246import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.panel.FamaMacBethPanelRegression; 
    5347import com.numericalmethod.algoquant.model.factormodel.regression.famamacbeth.panel.FamaMacBethPanelRegressionResults; 
    … …  
    5852import java.net.MalformedURLException; 
    5953import java.text.ParseException; 
    60 import java.util.ArrayList; 
    61 import java.util.Arrays; 
    62 import java.util.List; 
    63 import java.util.Set; 
     54import java.util.*; 
    6455import java.util.zip.ZipException; 
    6556import org.joda.time.DateTime; 
    … …  
    134125            stockIDs); 
    135126 
    136         Set<Equity> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
     127        Set<Stock> equities = MarketSnapshotUtils.getEquitiesFromFirstSnapshot(marketSnapshots); 
    137128 
    138129        LOGGER.info(String.format("number of companies available for analysis: %d", equities.size())); 
    … …  
    178169 
    179170    private SequentialCache<Double> getHSIData(DateTime startDate, DateTime endDate) { 
    180         Equity equityProduct = HSI.getInstance().as(Equity.class); 
     171        Stock stockProduct = HSI.getInstance().as(Stock.class); 
    181172 
    182173        String dataFolder = "./log/HSI"; 
    183         YahooEOD eod = new YahooEOD(equityProduct, dataFolder, dataFolder); 
     174        YahooEOD eod = new YahooEOD(stockProduct, dataFolder, dataFolder); 
    184175 
    185         DoubleEntryTransformer<EquityEOD> transformer = DoubleEntryTransformers.EQUITYEOD; 
     176        DoubleEntryTransformer<StockEOD> transformer = DoubleEntryTransformers.STOCK_EOD; 
    186177 
    187178        return transformer.doProcess(eod.getCache(startDate.minusWeeks(1), endDate)); // TODO: remove this hack by fixing getCache() 

  • demo/src/main/java/com/numericalmethod/algoquant/model/infantino2010/demo/Demo010.java

    r1438 r1495  
    7676 
    7777    public static void main(String[] args) { 
    78         List<Product> products = ProductUtils.newEquityProductList( 
     78        List<Product> products = ProductUtils.newStockProductList( 
    7979            new String[]{ 
    8080            "AAPL", "GOOG", "AMZN", "IBM", "HPQ", "MSFT", "CSCO", "ORCL", "INTC", "YHOO"}, 

  • demo/src/main/java/com/numericalmethod/algoquant/model/kst1995/demo/Demo020.java

    r1438 r1495  
    2727import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    2828import com.numericalmethod.algoquant.data.structure.TimedEntry; 
    29 import com.numericalmethod.algoquant.data.type.EquityEOD; 
     29import com.numericalmethod.algoquant.data.type.StockEOD; 
    3030import com.numericalmethod.algoquant.execution.product.Product; 
    31 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    3231import com.numericalmethod.algoquant.execution.product.equity.Exchange; 
     32import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3333import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    34 import com.numericalmethod.algoquant.model.kst1995.GMA12; 
    35 import com.numericalmethod.algoquant.model.kst1995.KnightSatchellTran1995; 
    36 import com.numericalmethod.algoquant.model.kst1995.KnightSatchellTran1995MLE; 
     34import com.numericalmethod.algoquant.model.kst1995.*; 
    3735import com.numericalmethod.algoquant.model.returns.ReturnCalculators; 
    3836import static com.numericalmethod.nmutils.NMUtils.*; 
    … …  
    6260        // setup data source 
    6361        Product product = HSI.getInstance(); 
    64         Equity equity = product.as(Equity.class); 
     62        Stock stock = product.as(Stock.class); 
    6563        String dataFolder = "./log/Yahoo"; 
    66         YahooEOD yahoo = new YahooEOD(equity, dataFolder, dataFolder); 
     64        YahooEOD yahoo = new YahooEOD(stock, dataFolder, dataFolder); 
    6765 
    6866        List<Double> px = new ArrayList<Double>(); 
    69         SequentialCache<EquityEOD> cache = yahoo.getCache(begin, end); 
    70         for (TimedEntry<EquityEOD> entry : cache) { 
     67        SequentialCache<StockEOD> cache = yahoo.getCache(begin, end); 
     68        for (TimedEntry<StockEOD> entry : cache) { 
    7169            px.add(entry.getData().getAdjClose()); 
    7270        } 

  • demo/src/main/java/com/numericalmethod/algoquant/model/lai2010/demo/DemoLai2010Signal.java

    r1438 r1495  
    6161 
    6262        /* list the products to be traded */ 
    63         List<Product> products = ProductUtils.newEquityProductList( 
     63        List<Product> products = ProductUtils.newStockProductList( 
    6464            new String[]{ 
    6565            "ORCL", "GOOG", "AMZN", "IBM", "MSFT"}, 

  • demo/src/main/java/com/numericalmethod/algoquant/model/lai2010/demo/DemoPeriodicRebalancing.java

    r1444 r1495  
    6969    public static void main(String[] args) { 
    7070        /* list the products to be traded */ 
    71         List<Product> products = ProductUtils.newEquityProductList( 
     71        List<Product> products = ProductUtils.newStockProductList( 
    7272            new String[]{ 
    7373            "ORCL", "GOOG", "AMZN", "IBM", "MSFT"}, 

  • demo/src/main/java/com/numericalmethod/algoquant/model/portfoliooptimization/markowitz/signal/demo/DemoMarkowitz.java

    r1438 r1495  
    5555    public static void main(String[] args) { 
    5656        /* list the products to be traded */ 
    57         List<Product> products = ProductUtils.newEquityProductList( 
     57        List<Product> products = ProductUtils.newStockProductList( 
    5858            new String[]{ 
    5959            "0019.HK", 

  • demo/src/main/java/com/numericalmethod/algoquant/model/signal/crossover/demo/DemoBatchParamSimulation.java

    r1467 r1495  
    3131import com.numericalmethod.algoquant.execution.performance.report.PerformanceReport; 
    3232import com.numericalmethod.algoquant.execution.product.Product; 
    33 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     33import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3434import com.numericalmethod.algoquant.execution.simulation.batch.BatchParameterizedSimulation; 
    3535import com.numericalmethod.algoquant.execution.simulation.batch.BatchSimulation.SimulationException; 
    … …  
    114114 
    115115    private DepthCaches getDepthCaches() { 
    116         DateTimeZone tz = product.as(Equity.class).getExchange().timeZone; 
     116        DateTimeZone tz = product.as(Stock.class).getExchange().timeZone; 
    117117        DateTime begin = JodaTimeUtils.getDate(2008, 1, 1, tz); 
    118118        DateTime end = JodaTimeUtils.getDate(2010, 12, 31, tz); 

  • demo/src/main/java/com/numericalmethod/algoquant/model/signal/crossover/demo/DemoSMA2CrossoverDynamic_010.java

    r1465 r1495  
    3737import com.numericalmethod.algoquant.execution.product.Currencies; 
    3838import com.numericalmethod.algoquant.execution.product.Product; 
    39 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     39import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4040import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    4141import com.numericalmethod.algoquant.execution.simulator.SimpleSimulator; 
    … …  
    7373 
    7474        // setup data source 
    75         DateTimeZone tz = product.as(Equity.class).getExchange().timeZone; 
     75        DateTimeZone tz = product.as(Stock.class).getExchange().timeZone; 
    7676        DateTime begin = JodaTimeUtils.getDate(1990, 1, 1, tz); 
    7777        DateTime end = JodaTimeUtils.getDate(2012, 2, 2, tz); 

  • demo/src/main/java/com/numericalmethod/algoquant/model/signal/crossover/demo/DemoSMA2_010.java

    r1465 r1495  
    3636import com.numericalmethod.algoquant.execution.product.Currencies; 
    3737import com.numericalmethod.algoquant.execution.product.Product; 
    38 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     38import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    3939import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    4040import com.numericalmethod.algoquant.execution.simulator.*; 
    … …  
    6666    public void run(Product product) { 
    6767        // setup data source 
    68         DateTimeZone tz = product.as(Equity.class).getExchange().timeZone; 
     68        DateTimeZone tz = product.as(Stock.class).getExchange().timeZone; 
    6969        DateTime begin = JodaTimeUtils.getDate(2008, 1, 1, tz); 
    7070        DateTime end = JodaTimeUtils.getDate(2009, 2, 2, tz); 

  • demo/src/main/java/com/numericalmethod/algoquant/model/signal/crossover/demo/DemoSMA2_011.java

    r1438 r1495  
    3939import com.numericalmethod.algoquant.execution.product.Currencies; 
    4040import com.numericalmethod.algoquant.execution.product.Product; 
    41 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     41import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4242import com.numericalmethod.algoquant.execution.product.equity.hkex.HSI; 
    4343import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    … …  
    7171    public void run(Product product) { 
    7272        // setup data source 
    73         DateTimeZone tz = product.as(Equity.class).getExchange().timeZone; 
     73        DateTimeZone tz = product.as(Stock.class).getExchange().timeZone; 
    7474        DateTime begin = JodaTimeUtils.getDate(1990, 1, 1, tz); 
    7575        DateTime end = JodaTimeUtils.getDate(2012, 8, 31, tz); 

  • demo/src/main/java/com/numericalmethod/algoquant/model/signal/demo/DemoPairsTrading.java

    r1438 r1495  
    3333import static com.numericalmethod.algoquant.execution.order.OrderUtils.newMarketOrder; 
    3434import com.numericalmethod.algoquant.execution.performance.SimplePerformanceAnalyzer; 
    35 import com.numericalmethod.algoquant.execution.performance.measure.PerformanceMeasure; 
    36 import com.numericalmethod.algoquant.execution.performance.measure.ProfitLoss; 
    37 import com.numericalmethod.algoquant.execution.performance.measure.SimpleExchangeRateTable; 
     35import com.numericalmethod.algoquant.execution.performance.measure.*; 
    3836import com.numericalmethod.algoquant.execution.performance.report.PerformanceReport; 
    3937import com.numericalmethod.algoquant.execution.product.Product; 
    40 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
    41 import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    42 import com.numericalmethod.algoquant.execution.simulator.SimpleSimulator; 
    43 import com.numericalmethod.algoquant.execution.simulator.Simulator; 
    44 import com.numericalmethod.algoquant.execution.strategy.BrokerageService; 
    45 import com.numericalmethod.algoquant.execution.strategy.SignalPlottable; 
    46 import com.numericalmethod.algoquant.execution.strategy.Strategy; 
     38import com.numericalmethod.algoquant.execution.product.equity.Stock; 
     39import com.numericalmethod.algoquant.execution.simulator.*; 
     40import com.numericalmethod.algoquant.execution.strategy.*; 
    4741import com.numericalmethod.algoquant.execution.strategy.handler.DepthHandler; 
    4842import com.numericalmethod.algoquant.model.signal.PlainDoubleSignal; 
    … …  
    5347import com.numericalmethod.suanshu.number.DoubleUtils; 
    5448import static java.lang.Math.abs; 
    55 import java.util.ArrayList; 
    56 import java.util.Arrays; 
    57 import java.util.Collection; 
    58 import java.util.List; 
    59 import java.util.Map; 
     49import java.util.*; 
    6050import org.joda.time.DateTime; 
    6151import org.slf4j.Logger; 
    … …  
    8979    @Override 
    9080    public void onDepthUpdate(DateTime now, Depth depth, MarketCondition mc, TradeBlotter blotter, 
    91         BrokerageService broker) { 
     81                              BrokerageService broker) { 
    9282 
    9383        if (!isReady) { 
    … …  
    131121        // select product 1 
    132122        final Product product1 = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.GOOG.getInstance(); 
    133         Equity equityProperty1 = product1.as(Equity.class); 
     123        Stock stockProperty1 = product1.as(Stock.class); 
    134124 
    135125        // select product 2 
    136126        final Product product2 = com.numericalmethod.algoquant.execution.product.equity.usa.nasdaq.MSFT.getInstance(); 
    137         Equity equityProperty2 = product2.as(Equity.class); 
     127        Stock stockProperty2 = product2.as(Stock.class); 
    138128 
    139129        // simulation time 
    140         DateTime begin = JodaTimeUtils.getDate(2010, 1, 1, equityProperty1.getExchange().timeZone); 
     130        DateTime begin = JodaTimeUtils.getDate(2010, 1, 1, stockProperty1.getExchange().timeZone); 
    141131        DateTime end = begin.plusYears(1); 
    142132 
    143133        // construct depth source mapping 
    144         YahooEOD yahoo1 = new YahooEOD(equityProperty1); 
    145         YahooEOD yahoo2 = new YahooEOD(equityProperty2); 
     134        YahooEOD yahoo1 = new YahooEOD(stockProperty1); 
     135        YahooEOD yahoo2 = new YahooEOD(stockProperty2); 
    146136        DepthCaches depthCaches = new DepthCaches(); 
    147         depthCaches.addCache(product1, DepthCacheUtils.fromEquityEODCache(product1, yahoo1.getCache(begin, end))); 
    148         depthCaches.addCache(product2, DepthCacheUtils.fromEquityEODCache(product2, yahoo2.getCache(begin, end))); 
     137        depthCaches.addCache(product1, DepthCacheUtils.fromStockEODCache(product1, yahoo1.getCache(begin, end))); 
     138        depthCaches.addCache(product2, DepthCacheUtils.fromStockEODCache(product2, yahoo2.getCache(begin, end))); 
    149139 
    150140        // create strategy 

  • demo/src/main/java/com/numericalmethod/algoquant/model/signal/volume/demo/DemoADL.java

    r1438 r1495  
    2727import com.numericalmethod.algoquant.data.historicaldata.DepthCacheUtils; 
    2828import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    29 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    3029import com.numericalmethod.algoquant.data.type.MarketCondition; 
     30import com.numericalmethod.algoquant.data.type.StockEOD; 
    3131import com.numericalmethod.algoquant.execution.component.chart.plotter.SimpleStrategyPlotter; 
    3232import com.numericalmethod.algoquant.execution.component.tradeblotter.TradeBlotter; 
    … …  
    3434import static com.numericalmethod.algoquant.execution.order.OrderUtils.newMarketOrder; 
    3535import com.numericalmethod.algoquant.execution.performance.SimplePerformanceAnalyzer; 
    36 import com.numericalmethod.algoquant.execution.performance.measure.ExchangeRateTable; 
    37 import com.numericalmethod.algoquant.execution.performance.measure.PerformanceMeasure; 
    38 import com.numericalmethod.algoquant.execution.performance.measure.ProfitLoss; 
    39 import com.numericalmethod.algoquant.execution.performance.measure.SimpleExchangeRateTable; 
     36import com.numericalmethod.algoquant.execution.performance.measure.*; 
    4037import com.numericalmethod.algoquant.execution.performance.measure.ir.InformationRatioByTrade; 
    4138import com.numericalmethod.algoquant.execution.performance.measure.omega.OmegaByTrade; 
    … …  
    4340import com.numericalmethod.algoquant.execution.product.Currencies; 
    4441import com.numericalmethod.algoquant.execution.product.Product; 
    45 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     42import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4643import com.numericalmethod.algoquant.execution.product.equity.usa.nyse.NYSEProduct; 
    47 import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    48 import com.numericalmethod.algoquant.execution.simulator.SimpleSimulator; 
    49 import com.numericalmethod.algoquant.execution.simulator.Simulator; 
     44import com.numericalmethod.algoquant.execution.simulator.*; 
    5045import com.numericalmethod.algoquant.execution.simulator.subscription.Subscribable; 
    51 import com.numericalmethod.algoquant.execution.strategy.BrokerageService; 
    52 import com.numericalmethod.algoquant.execution.strategy.ProductParams; 
    53 import com.numericalmethod.algoquant.execution.strategy.SignalPlottable; 
    54 import com.numericalmethod.algoquant.execution.strategy.Strategy; 
    55 import com.numericalmethod.algoquant.execution.strategy.handler.EquityEODHandler; 
     46import com.numericalmethod.algoquant.execution.strategy.*; 
     47import com.numericalmethod.algoquant.execution.strategy.handler.StockEODHandler; 
    5648import com.numericalmethod.algoquant.model.signal.movingaverage.MovingAverage; 
    5749import com.numericalmethod.algoquant.model.signal.volume.AccumulationDistributionLine; 
    … …  
    7971    private static final Logger LOGGER = getClassLogger(); 
    8072 
    81     public static class SimpleADLStrategy implements Strategy, SignalPlottable, EquityEODHandler { 
     73    public static class SimpleADLStrategy implements Strategy, SignalPlottable, StockEODHandler { 
    8274 
    8375        private final MovingAverage marginalPriceMA; 
    … …  
    9486 
    9587        @Override 
    96         public void onEODUpdate(DateTime now, EquityEOD eod, MarketCondition mc, 
    97             TradeBlotter blotter, 
    98             BrokerageService broker) { 
     88        public void onEODUpdate(DateTime now, StockEOD eod, MarketCondition mc, 
     89                                TradeBlotter blotter, 
     90                                BrokerageService broker) { 
    9991            double price = eod.getClose(); 
    10092            if (previousPrice != null) { 
    … …  
    119111 
    120112            return (DoubleUtils.compare(qty, 0., 1e-5) == 0) 
    121                 ? Collections.<Order>emptyList() 
    122                 : Collections.<Order>singletonList(newMarketOrder(params.product, qty)); 
     113                   ? Collections.<Order>emptyList() 
     114                   : Collections.<Order>singletonList(newMarketOrder(params.product, qty)); 
    123115        } 
    124116 
    … …  
    143135        String dataFolder = "./log/Yahoo"; 
    144136        Product product = new NYSEProduct("JWN"); 
    145         Equity equityProduct = product.as(Equity.class); 
    146         DateTime begin = JodaTimeUtils.getDate(2010, 2, 1, equityProduct.getExchange().timeZone); 
    147         DateTime end = JodaTimeUtils.getDate(2010, 12, 22, equityProduct.getExchange().timeZone); 
    148         YahooEOD yahoo = new YahooEOD(equityProduct, dataFolder, dataFolder); 
     137        Stock stockProduct = product.as(Stock.class); 
     138        DateTime begin = JodaTimeUtils.getDate(2010, 2, 1, stockProduct.getExchange().timeZone); 
     139        DateTime end = JodaTimeUtils.getDate(2010, 12, 22, stockProduct.getExchange().timeZone); 
     140        YahooEOD yahoo = new YahooEOD(stockProduct, dataFolder, dataFolder); 
    149141 
    150142        int lag = 10; 
    … …  
    154146        LOGGER.info(strategy.toString()); 
    155147 
    156         SequentialCache<EquityEOD> equityEODCache = yahoo.getCache(begin, end); 
     148        SequentialCache<StockEOD> stockEODCache = yahoo.getCache(begin, end); 
    157149 
    158150        // create source of market depth 
    159151        DepthCaches depthCaches = DepthCaches.newInstanceWithSingleCache( 
    160             product, DepthCacheUtils.fromEquityEODCache(product, equityEODCache)); 
     152            product, DepthCacheUtils.fromStockEODCache(product, stockEODCache)); 
    161153 
    162154        Collection<SequentialCache<? extends Subscribable>> subscribables = 
    163155            new ArrayList<SequentialCache<? extends Subscribable>>(); 
    164         subscribables.add(equityEODCache); 
     156        subscribables.add(stockEODCache); 
    165157 
    166158        // run simulation 

  • demo/src/main/java/com/numericalmethod/algoquant/model/signal/volume/demo/DemoCMF.java

    r1438 r1495  
    2727import com.numericalmethod.algoquant.data.historicaldata.DepthCacheUtils; 
    2828import com.numericalmethod.algoquant.data.historicaldata.yahoo.YahooEOD; 
    29 import com.numericalmethod.algoquant.data.type.EquityEOD; 
    3029import com.numericalmethod.algoquant.data.type.MarketCondition; 
     30import com.numericalmethod.algoquant.data.type.StockEOD; 
    3131import com.numericalmethod.algoquant.execution.component.chart.plotter.SimpleStrategyPlotter; 
    3232import com.numericalmethod.algoquant.execution.component.tradeblotter.TradeBlotter; 
    … …  
    3434import static com.numericalmethod.algoquant.execution.order.OrderUtils.newMarketOrder; 
    3535import com.numericalmethod.algoquant.execution.performance.SimplePerformanceAnalyzer; 
    36 import com.numericalmethod.algoquant.execution.performance.measure.ExchangeRateTable; 
    37 import com.numericalmethod.algoquant.execution.performance.measure.PerformanceMeasure; 
    38 import com.numericalmethod.algoquant.execution.performance.measure.ProfitLoss; 
    39 import com.numericalmethod.algoquant.execution.performance.measure.SimpleExchangeRateTable; 
     36import com.numericalmethod.algoquant.execution.performance.measure.*; 
    4037import com.numericalmethod.algoquant.execution.performance.measure.ir.InformationRatioByTrade; 
    4138import com.numericalmethod.algoquant.execution.performance.measure.omega.OmegaByTrade; 
    … …  
    4340import com.numericalmethod.algoquant.execution.product.Currencies; 
    4441import com.numericalmethod.algoquant.execution.product.Product; 
    45 import com.numericalmethod.algoquant.execution.product.equity.Equity; 
     42import com.numericalmethod.algoquant.execution.product.equity.Stock; 
    4643import com.numericalmethod.algoquant.execution.product.equity.usa.nyse.NYSEProduct; 
    47 import com.numericalmethod.algoquant.execution.simulator.DepthCaches; 
    48 import com.numericalmethod.algoquant.execution.simulator.SimpleSimulator; 
    49 import com.numericalmethod.algoquant.execution.simulator.Simulator; 
     44import com.numericalmethod.algoquant.execution.simulator.*; 
    5045import com.numericalmethod.algoquant.execution.simulator.subscription.Subscribable; 
    51 import com.numericalmethod.algoquant.execution.strategy.BrokerageService; 
    52 import com.numericalmethod.algoquant.execution.strategy.ProductParams; 
    53 import com.numericalmethod.algoquant.execution.strategy.SignalPlottable; 
    54 import com.numericalmethod.algoquant.execution.strategy.Strategy; 
    55 import com.numericalmethod.algoquant.execution.strategy.handler.EquityEODHandler; 
     46import com.numericalmethod.algoquant.execution.strategy.*; 
     47import com.numericalmethod.algoquant.execution.strategy.handler.StockEODHandler; 
    5648import com.numericalmethod.algoquant.model.signal.movingaverage.MovingAverage; 
    5749import com.numericalmethod.algoquant.model.signal.volume.ChaikinMoneyFlow; 
    … …  
    7769public class DemoCMF { 
    7870 
    79     public static class SimpleADLStrategy implements Strategy, SignalPlottable, EquityEODHandler { 
     71    public static class SimpleADLStrategy implements Strategy, SignalPlottable, StockEODHandler { 
    8072 
    8173        private final MovingAverage marginalPriceMA; 
    … …  
    9385        public void onEODUpdate( 
    9486            DateTime now, 
    95             EquityEOD eod, 
     87            StockEOD eod, 
    9688            MarketCondition mc, 
    9789            TradeBlotter blotter, 
    … …  
    117109 
    118110            return (DoubleUtils.compare(qty, 0., 1e-5) == 0) 
    119                 ? Collections.<Order>emptyList() 
    120                 : Collections.<Order>singletonList(newMarketOrder(params.product, qty)); 
     111                   ? Collections.<Order>emptyList() 
     112                   : Collections.<Order>singletonList(newMarketOrder(params.product, qty)); 
    121113        } 
    122114 
    … …  
    133125        } 
    134126    } 
     127 
    135128    private static final Logger LOGGER = getClassLogger(); 
    136129 
    … …  
    139132        String dataFolder = "./log/Yahoo"; 
    140133        Product product = new NYSEProduct("FCX"); 
    141         Equity equityProduct = product.as(Equity.class); 
    142         DateTimeZone tz = equityProduct.getExchange().timeZone; 
     134        Stock stockProduct = product.as(Stock.class); 
     135        DateTimeZone tz = stockProduct.getExchange().timeZone; 
    143136        DateTime begin = JodaTimeUtils.getDate(2010, 2, 1, tz); 
    144137        DateTime end = JodaTimeUtils.getDate(2010, 12, 22, tz); 
    145         YahooEOD yahoo = new YahooEOD(equityProduct, dataFolder, dataFolder); 
     138        YahooEOD yahoo = new YahooEOD(stockProduct, dataFolder, dataFolder); 
    146139 
    147140        int lag = 20; 
    … …  
    151144        LOGGER.info(strategy.toString()); 
    152145 
    153         SequentialCache<EquityEOD> equityEODCache = yahoo.getCache(begin, end); 
     146        SequentialCache<StockEOD> stockEODCache = yahoo.getCache(begin, end); 
    154147 
    155148        // create source of market depth 
    156149        DepthCaches depthCaches = DepthCaches.newInstanceWithSingleCache( 
    157             product, DepthCacheUtils.fromEquityEODCache(product, equityEODCache)); 
     150            product, DepthCacheUtils.fromStockEODCache(product, stockEODCache)); 
    158151 
    159152        Collection<SequentialCache<? extends Subscribable>> subscribables = 
    160153            new ArrayList<SequentialCache<? extends Subscribable>>(); 
    161         subscribables.add(equityEODCache); 
     154        subscribables.add(stockEODCache); 
    162155 
    163156        // run simulation 
Note: See TracChangeset for help on using the changeset viewer.