Trading System API  3.0
Library for Simulating and Deploying Trading and Investment Strategies
TSAFunctors.h
1 
2 /* ===================================================================
3 *
4 * T R A D I N G S Y S T E M A P I ™
5 * Copyright © 1999 - 2014 by Peter Ritter ( TradingSystemAPI.com )
6 * A L L R I G H T S R E S E R V E D
7 *
8 * Consult your license regarding permissions and restrictions.
9 * You may obtain a copy of the License at:
10 * http://www.TradingSystemAPI.com/licenses/LICENSE-TSAPI-3.0.html
11 *
12 * ====================================================================
13 */
14 
15 #ifndef TSA_FUNCTORS__INCLUDED
16 #define TSA_FUNCTORS__INCLUDED
17 
18 #include <functional>
19 #include <vector>
20 #include <memory>
21 #include <map>
22 
23 #include "TSATypeDef.h"
24 #include "TSATypeDef.h"
25 #include "TSASeriesTemplate.h"
26 #include "TSAFunctorParent.h"
27 #include "TSASeriesVariant.h"
28 #include "TSASeriesImp.h"
29 #include "TSAFunctions.h"
30 
31 namespace tsa {
32 
35 
36  namespace functor {
37 
41  class dll_export max : public functor::parent<double> {//MF
43  size_t m_period;
44  double dMax;
45  size_t nMaxIdx;
46  public:
48  max(void);
50  const parent& operator()(const series<double>& series_, size_t period);
51  public:// formula
52  size_t m_const_period;
53  series_cref<double> m_series;
54  public:
55  max(const series<double>& ser, size_t period)
56  : parent(1), m_series(ser), m_const_period(period) {
57  }
58  virtual void evaluate(void)override {
59 
60  operator()(m_series, m_const_period);
61  }
62  virtual bool input_data_is_ok(void)override {
63  return m_series.size_ok(m_const_period);
64  }
65  };
66 
68  typedef max highest;
69 
71 
73  class dll_export min : public functor::parent<double> {//MF
74  //bool m_init = false;
75  size_t m_period;
76  double dMin;
77  size_t nMinIdx;
78  public:
80  min(void);
82  const parent& operator()(const series<double>& series_, size_t _period);
83  public:// formula
84  size_t m_const_period;
85  series_cref<double> m_series;
86  public:
87  min(const series<double>& ser, size_t period)
88  : parent(1), m_series(ser), m_const_period(period) {
89  }
90  virtual void evaluate(void)override {
91  operator()(m_series, m_const_period);
92  }
93  virtual bool input_data_is_ok(void)override {
94  return m_series.size_ok(m_const_period);
95  }
96  };
97 
99  typedef min lowest;
100 
102 
104  class dll_export sum : public functor::parent<double> {//MF
105  double m_sum;
106  size_t m_period;
107  public:
109  sum(void);
111  const parent& operator()(const series<double>& series_, size_t _period);
112  public:// formula
113  size_t m_const_period;
114  series_cref<double> m_series;
115  public:
116  sum(series_cref<double> ser, size_t period)
117  : parent(1), m_series(ser), m_const_period(period) {
118  }
119  virtual void evaluate(void)override {
120  operator()(m_series, m_const_period);
121  }
122  virtual bool input_data_is_ok(void)override {
123  return m_series.size_ok(m_const_period);
124  }
125  };
126 
128 
130  class dll_export sum_squares : public functor::parent<double> {//MF
131  series<double> s_squares;
132  functor::sum SUM;
133  size_t m_period;
134  public:
136  sum_squares(void);
138  const parent& operator()(const series<double>& series, size_t period);
139  public:// formula
140  size_t m_const_period;
141  series_cref<double> m_series;
142  public:
143  sum_squares(const series<double>& ser, size_t period)
144  : parent(1), m_series(ser), m_const_period(period) {
145  }
146  virtual void evaluate(void)override {
147  operator()(m_series, m_const_period);
148  }
149  virtual bool input_data_is_ok(void)override {
150  return m_series.size_ok(m_const_period);
151  }
152  };
153 
155 
157  class dll_export sum_pos : public functor::parent<double> {//MF
158  double m_sum;
159  size_t m_period;
160  public:
162  sum_pos(void);
164  const parent& operator()(const series<double>& series_, size_t period);
165  public:// formula
166  size_t m_const_period;
167  series_cref<double> m_series;
168  public:
169  sum_pos(const series<double>& ser, size_t period)
170  : parent(1), m_series(ser), m_const_period(period) {
171  }
172  virtual void evaluate(void)override {
173  operator()(m_series, m_const_period);
174  }
175  virtual bool input_data_is_ok(void)override {
176  return m_series.size_ok(m_const_period);
177  }
178  };
179 
181 
183  class dll_export sum_neg : public functor::parent<double> {//MF
184  double m_sum;
185  size_t m_period;
186  public:
188  sum_neg(void);
190  const parent& operator()(const series<double>& series_, size_t period);
191  public:// formula
192  size_t m_const_period;
193  series_cref<double> m_series;
194  public:
195  sum_neg(const series<double>& ser, size_t period)
196  : parent(1), m_series(ser), m_const_period(period) {
197  }
198  virtual void evaluate(void)override {
199  operator()(m_series, m_const_period);
200  }
201  virtual bool input_data_is_ok(void)override {
202  return m_series.size_ok(m_const_period);
203  }
204  };//t
205 
207 
210  class dll_export average : public functor::parent<double> {//MF
211  functor::sum SUM;
212  public:
214  average(void);
215  virtual ~average(void);
217  parent& operator()(const series<double>& data, size_t period);
218  public:// formula
219  size_t m_const_period;
220  series_cref<double> m_series;
221  public:
222  average(const series<double>& ser, size_t period)
223  : parent(1), m_series(ser), m_const_period(period) {
224  }
225  virtual void evaluate(void)override {
226  operator()(m_series, m_const_period);
227  }
228  virtual bool input_data_is_ok(void)override {
229  return m_series.size_ok(m_const_period);
230  }
231  };//t
232 
234  typedef average SMA;
235 
237 
240  class dll_export average_exp : public functor::parent<double> {//MF
241  double m_exma;
242  double m_factor;
243  size_t m_period;
244  public:
246  average_exp(void);
248  const parent& operator()(const series<double>& _ser, size_t _period);
249  public:// formula
250  size_t m_const_period;
251  series_cref<double> m_series;
252  public:
253  average_exp(const series<double>& ser, size_t period)
254  : parent(1), m_series(ser), m_const_period(period) {
255  }
256  virtual void evaluate(void)override {
257  operator()(m_series, m_const_period);
258  }
259  virtual bool input_data_is_ok(void)override {
260  return m_series.size_ok(m_const_period);
261  }
262  };//t
263 
265  typedef average_exp EMA;
266 
267 
268 
270 
273  class dll_export variance : public functor::parent<double> {//MF
274  size_t m_period;
275  double m_dCurrSumOfSquares;
276  double m_dCurrSum;
277  public:
279  variance(void);
281  const parent& operator()(const series<double>& _ser, size_t _period);
282  public:// formula
283  size_t m_const_period;
284  series_cref<double> m_series;
285  public:
286  variance(const series<double>& ser, size_t period)
287  : parent(1), m_series(ser), m_const_period(period) {
288  }
289  virtual void evaluate(void)override {
290  operator()(m_series, m_const_period);
291  }
292  virtual bool input_data_is_ok(void)override {
293  return m_series.size_ok(m_const_period + 1);
294  }
295  };//t
296 
298 
301  class dll_export stdev : public functor::parent<double> {//MF
302  size_t m_period;
303  functor::variance VAR;
304  public:
306  stdev(void);
308  const parent& operator()(const series<double>& _ser, size_t _period);
309  public:// formula
310  size_t m_const_period;
311  series_cref<double> m_series;
312  public:
313  stdev(const series<double>& ser, size_t period)
314  : parent(1), m_series(ser), m_const_period(period) {
315  }
316  virtual void evaluate(void)override {
317  operator()(m_series, m_const_period);
318  }
319  virtual bool input_data_is_ok(void)override {
320  return m_series.size_ok(m_const_period + 1);
321  }
322  };//t
323 
325 
328  class dll_export correlation : public functor::parent<double> {//MF
329  size_t m_period;
330  double SumX;
331  double SumXSqu;
332  double SumY;
333  double SumYSqu;
334  double SumXY;
335  public:
337  correlation(void);
339  const parent& operator()(const series<double>& ser_a,
340  const series<double>& ser_b, size_t _period);
341  public:// formula
342  size_t m_const_period;
343  series_cref<double> m_ser_a;
344  series_cref<double> m_ser_b;
345  public:
346  correlation(const series<double>& ser_a, const series<double>& ser_b, size_t period)
347  : parent(1), m_ser_a(ser_a), m_ser_b(ser_b), m_const_period(period) {
348  }
349  virtual void evaluate(void)override {
350  operator()(m_ser_a, m_ser_b, m_const_period);
351  }
352  virtual bool input_data_is_ok(void)override {
353  return m_ser_a.size_ok(m_const_period) && m_ser_b.size_ok(m_const_period);
354  }
355  };//t
356 
358  typedef correlation CORR;
359 
361 
363 
364  //NOT IMPLEMENTED!
366  class dll_export chaikin_volatility : public functor::parent<double> {
367  //bool m_init = false;
368  size_t m_period_short;
369  size_t m_period_long;
370  functor::SMA f_avg_hilo;
371  series<double> s_hilo;
372  series<double> s_avg;
373  public:
375  chaikin_volatility(void);
377  const parent& operator()(
378  double hi,
379  double lo,
380  size_t _period_avg = 10,
381  size_t _period_roc = 10
382  );
383  };//t
384 
385 
387  //NOT IMPLEMENTED
389  class dll_export coppock : public functor::parent<double> {
390  size_t m_period_roc_short;
391  size_t m_period_roc_long;
392  series<double> s_roc_sum;
393  public:
395  coppock(void);
397  const parent& operator()(double cl, size_t _period_roc_short = 10,
398  size_t _period_roc_long = 11
399  );
400  };//t
401 
402 
404 
406  class dll_export average_exp_by_wilder : public functor::parent<double> {//MF
407  size_t m_period;
408  double m_avg;
409  public:
411  average_exp_by_wilder(void);
413  const parent& operator()(const series<double>& _ser, size_t _period);
414  public:// formula
415  size_t m_const_period;
416  series_cref<double> m_series;
417  public:
418  average_exp_by_wilder(const series<double>& ser, size_t period)
419  : parent(1), m_series(ser), m_const_period(period) {
420  }
421  virtual void evaluate(void)override {
422  operator()(m_series, m_const_period);
423  }
424  virtual bool input_data_is_ok(void)override {
425  return m_series.size_ok(m_const_period);
426  }
427  };//t
428 
430 
433  class dll_export RSI : public functor::parent<double> { //MF
434  size_t m_period;
435  series<double> s_chg_pos;
436  series<double> s_chg_neg;
437 
438  functor::average_exp_by_wilder WEMA_UP;
439  functor::average_exp_by_wilder WEMA_DN;
440  public:
442  RSI(void);
444  const parent& operator()(const series<double>& _ser, size_t _period);
445  public:// formula
446  size_t m_const_period;
447  series_cref<double> m_series;
448  public:
449  RSI(const series<double>& ser, size_t period)
450  : parent(1), m_series(ser), m_const_period(period) {
451  }
452  virtual void evaluate(void)override {
453  operator()(m_series, m_const_period);
454  }
455  virtual bool input_data_is_ok(void)override {
456  return m_series.size_ok(m_const_period);
457  }
458  };//t
459 
460 
462 
464  class dll_export stochastic_raw_k : public functor::parent<double> { //MF
465  size_t m_period;
466  min MIN;
467  max MAX;
468  public:
470  stochastic_raw_k(void);
472  const parent& operator()(const series<double>& h,
473  const series<double>& l,
474  const series<double>& c,
475  size_t _period);
476  public:
477  size_t m_const_period;
478  series_cref<double> m_hi;
479  series_cref<double> m_lo;
480  series_cref<double> m_cl;
481  public:
482  stochastic_raw_k(series_cref<double> hi, series_cref<double> lo,
483  series_cref<double> cl, size_t period)
484  : parent(1), m_hi(hi), m_lo(lo), m_cl(cl), m_const_period(period) {
485  }
486  virtual void evaluate(void)override {
487  operator()(m_hi, m_lo, m_cl, m_const_period);
488  }
489  virtual bool input_data_is_ok(void)override {
490  return m_hi.size_ok(m_const_period) &&
491  m_lo.size_ok(m_const_period) && m_cl.size_ok(m_const_period);
492  }
493  };//t
494 
496 
498  class dll_export stochastic : public functor::parent<double> { //MF
499  private:
500  size_t m_period;
501  //series<double> s_stoch_k;
502  series<double> s_smoothed_k;
503  functor::stochastic_raw_k RAW_K;
504  functor::SMA SMA_K;
505  functor::SMA SMA_D;
506  public:
508  stochastic(void);
509 
535  const parent& operator()(
536  const series<double>& hi,
537  const series<double>& lo,
538  const series<double>& cl,
539  size_t period,
540  size_t k_smooth_period = 3,
541  size_t d_smooth_period = 3
542 
543  );
544 
545  double k(void)const { return parent::value(0); }
546  double d(void)const { return parent::value(1); }
547 
548  public:
549  size_t m_const_period;
550  size_t m_smooth_k_period;
551  size_t m_smooth_d_period;
552  series_cref<double> m_hi;
553  series_cref<double> m_lo;
554  series_cref<double> m_cl;
555  public:
556  stochastic(const series<double>& hi, const series<double>& lo, const series<double>& cl,
557  size_t period, size_t k_smooth_period, size_t d_smooth_period)
558  : parent(2), m_hi(hi), m_lo(lo), m_cl(cl),
559  m_const_period(period), m_smooth_k_period(k_smooth_period), m_smooth_d_period(d_smooth_period) {}
560  virtual void evaluate(void)override {
561  operator()(m_hi, m_lo, m_cl, m_const_period, m_smooth_k_period, m_smooth_d_period);
562  }
563  virtual bool input_data_is_ok(void)override {
564  return m_hi.size_ok(m_const_period) && m_lo.size_ok(m_const_period) && m_cl.size_ok(m_const_period);
565  }
566 
567  };//t
568 
570 
572  class volatility : public functor::parent<double> { //MF
573  series<double> s_chg;
574  functor::stdev f_stdev;
575  double m_time_factor;
576  public:
577  size_t m_period;
578  size_t m_ivals_per_year;
579  public:
580 
581  series_cref<double> m_series;
582  size_t m_const_period;
583  size_t m_num_ivals_in_year;
585  volatility(void);
587  const parent& operator()(const series<double>& _data,
588  size_t _period, size_t _numberOfIntervalsInYear);
589  volatility(const series<double>& ser, size_t period, size_t num_ivals_in_year)
590  : parent(1), m_series(ser), m_const_period(period), m_num_ivals_in_year(num_ivals_in_year) {
591  }
592  virtual void evaluate(void)override {
593  operator()(m_series, m_const_period, m_num_ivals_in_year);
594  }
595  virtual bool input_data_is_ok(void)override {
596  return m_series.size_ok(m_const_period);
597  }
598 
599  };//t
600 
601 
603  class commodity_channel_index : public functor::parent<double> {//MF
604  private:
605  series<double> s_typical_price;
606  functor::SMA f_avg;
607  public:
608  size_t m_period;
609  public:
611  commodity_channel_index(void);
613  const parent& operator()(
614  const series<double>& hi,
615  const series<double>& lo,
616  const series<double>& cl,
617  size_t period
618  );
619  public:// formula
620  size_t m_const_period;
621  series_cref<double> m_hi;
622  series_cref<double> m_lo;
623  series_cref<double> m_cl;
624  public:
625  commodity_channel_index(const series<double>& hi,
626  const series<double>& lo, const series<double>& cl, size_t period)
627  : parent(1),
628  m_hi(hi),
629  m_lo(lo),
630  m_cl(cl),
631  m_const_period(period) {
632  }
633  virtual void evaluate(void)override {
634  operator()(m_hi, m_lo, m_cl, m_const_period);
635  }
636  virtual bool input_data_is_ok(void)override {
637  return m_hi.size_ok(m_const_period) && m_lo.size_ok(m_const_period) && m_cl.size_ok(m_const_period);
638  }
639  };
640 
641 
643 
645  class vortex_indicator : public functor::parent<double> {
646  series<double> s_true_range;
647  series<double> s_plus_vm;
648  series<double> s_minus_vm;
649  private:
651  vortex_indicator(void);
653  const parent& operator()(
654  const series<double>& _hi,
655  const series<double>& _lo,
656  const series<double>& _cl,
657  size_t period = 14
658  );
659  double positive()const { return parent::value(0); }
660  double negative(void)const { return parent::value(1); }
661  };
662 
664 
666  class relative_volatility : public functor::parent<double> {
667  private:
669  relative_volatility(void);
671  const parent& operator()(
672  const series<double>& _cl,
673  size_t period = 14
674  );
675  };
676 
678 
680  class on_balance_volume : public functor::parent<double> {
681  double m_obv = 0.0;
682  private:
684  on_balance_volume(void);
686  const parent& operator()(
687  const series<double>& _cl,
688  const series<double>& _vol
689  );
690  };
691 
692  typedef on_balance_volume OBV;
693 
695 
697  class aroon : public functor::parent<double> {
699  struct tuple_t {
700  double up;
701  double dn;
702  double oscillator;
703  };
704  series<bool> s_is_high;
705  series<bool> s_is_low;
706 
707  public:
709  aroon(void);
711  const parent& operator()(
712  const series<double>& highs,
713  const series<double>& lows,
714  size_t period = 25
715  );
716  double up(void)const { return parent::value(0); }
717  double dn(void)const { return parent::value(1); }
718  double osc(void)const { return parent::value(2); }
719  };
720 
721 
723 
725  class negative_volume_index : public functor::parent<double> {
726  double m_nvi = 1000.0;
727  size_t m_period;
728  functor::EMA f_avg_exp;
729  public:
731  negative_volume_index(void);
733  const parent& operator()(
734  const series<double>& cl,
735  const series<double>& vol,
736  size_t period
737  );
738  };
739 
741  typedef negative_volume_index NVI;
742 
744 
745  /* /// @brief Willianms %R indicator.
746  class williams_R : public functor::parent<double> {
747  size_t m_period;
748  public:
750  williams_R(void);
752  const parent& operator()(
753  const series<double>& hi,
754  const series<double>& lo,
755  const series<double>& cl,
756  size_t period
757  );
758  };*/
759 
760 
762 
763  }//namespace functor
764 
765 
766 
767  //IU Class representing a 'weighted basket' of stock (or other securities)
768  class dll_export weighted_basket : public object {
769  private:
770  struct BasketItem {
771  public:
772  string sSymbol;
773  double dWeight;
774  double dPercentOfTotal;
775  double dPositionSize;
776  double dPrevPositionSize;
777  double dPrice;
778  bool bPriceWasUpdated;
779  double dMultiplier;
780  };
781  typedef std::map<string, BasketItem> COMPONENTMAP;
782  COMPONENTMAP m_Components;
783  bool m_bFirstRebalanceCompleted;
784  size_t m_nRebalanceInterval;
785  size_t m_nBarsSinceLastReblance;
786  date_time m_LastRebalanceTimestamp;
787  date_time m_LastTimestamp;
788  double m_dStartValue;
789  double m_dTotalValueAtLastBar;
790  double m_dCashBalance;
791  bool m_bForcePriceUpdate;
792  public:
793  weighted_basket(void);
794  ~weighted_basket(void);
795  public:
796  void AddComponent(const tsa::string& symbol, double weight = 1.0);
797  void RemoveComponent(const tsa::string& symbol);
798  bool ComponentExists(const tsa::string& symbol) const;
799  void ResetWeight(const tsa::string& symbol, double weight);
800  const BasketItem& GetComponent(const tsa::string& symbol) const;
801  size_t Size(void) const;
802  //Any new cash is only distributed when there is a rebalance
803  void AddCash(double);
804  const date_time& GetLastTimestamp(void) const;
805  const date_time& GetLastRebalanceTimestamp(void) const;
806  public:
807  void UpdatePrice(const tsa::string& symbol, double price);
808  void SetForcePriceUpdate(bool);
809  bool GetForcePriceUpdate(void) const;
810  double CashBalance(void) const;
811  public:
812  size_t RebalanceInterval(void) const;
813  void RebalanceInterval(size_t);
814  void Rebalance(const date_time&);
815  void CalculateMultipliers(void);
816  double CalculateTotalValue(void) const; //Cash and Stocks
817  double TotalValueAtLastCompletedBar(void);
818  size_t BarsSinceLastRebalance(void);
819  void NotifyBarCompleted(const date_time&, bool rebalance = false);
820  double CalculateStockBasketValue(void) const;
821  public:
822  double GetPrice(const tsa::string& symbol) const;
823  double GetPositionSize(const tsa::string& symbol) const;
824  double GetPositionValue(const tsa::string& symbol) const;
825  double GetWeight(const tsa::string& symbol) const;
826  public:
827  void PrintState(std::ostream&) const;
828  };
829 
830 
831 } // namespace tsa
832 
833 
834 #endif
835 
836 
837 
tsa::max
double max(const series< double > &series, size_t period)
Returns the highest value found in series over given .
Definition: TSAFunctionsScalar.cpp:180
tsa::functor::coppock
Definition: TSAFunctors.h:389
tsa::functor::highest
max highest
Typedef. Same as class max;.
Definition: TSAFunctors.h:68
tsa::functor::sum_squares
Functor for calculating the sum of all values in a series over a given period.
Definition: TSAFunctors.h:130
tsa
Namespace for the &#39;Trading System API&#39; library.
Definition: original1.TSA3Core.cpp:20
tsa::variance
double variance(const series< double > &data, size_t period)
Returns the population variance in data over period.
Definition: TSAFunctionsScalar.cpp:122
tsa::functor::negative_volume_index
Nevative Volume Index by Fosback.
Definition: TSAFunctors.h:725
tsa::functor::average_exp
Functor for calculating the exponential average of all values in a series over a given period...
Definition: TSAFunctors.h:240
tsa::functor::sum_neg
Functor for calculating the sum of all negative values in a series over a given period.
Definition: TSAFunctors.h:183
tsa::functor::stdev
Functor for calculating the population standard deviation of all values in a series over a given peri...
Definition: TSAFunctors.h:301
tsa::functor::min
Functor for calculating the minimum value in a series over a given period.
Definition: TSAFunctors.h:73
tsa::functor::SMA
average SMA
Typedef. Save as class functor::average.
Definition: TSAFunctors.h:234
tsa::functor::correlation
Functor for calculating the correlation between two series over a given period.
Definition: TSAFunctors.h:328
tsa::functor::average
Functor for calculating the average of all values in a series over a given period.
Definition: TSAFunctors.h:210
tsa::functor::sum
Functor for calculating the sum of all values in a series over a given period.
Definition: TSAFunctors.h:104
tsa::functor::CORR
correlation CORR
Typedef. Same as class functor::correlation.
Definition: TSAFunctors.h:358
tsa::SUM
sref< double > SUM(const container &c)
Returns the sum of the current values of all series in given container c.
Definition: TSADSLMath.cpp:631
tsa::RSI
sref< double > RSI(sref< double > ser, size_t period)
Relative Strength Index.
Definition: TSADSLFinancial.cpp:446
tsa::MAX
sref< double > MAX(const container &c)
Returns the maximum current values of all series in given container c.
Definition: TSADSLMath.cpp:653
tsa::stdev
double stdev(const series< double > &data, size_t period)
Returns the population standard deviation in data over period.
Definition: TSAFunctionsScalar.cpp:142
tsa::object
Parent class for many library classes.
Definition: TSATypeDef.h:462
tsa::correlation
double correlation(const series< double > &x, const series< double > &y, size_t period)
Returns the correlation coefficient of series and series over given period.
Definition: TSAFunctionsScalar.cpp:148
tsa::functor::commodity_channel_index
CCI by Lambert. Functor for calculating Commodity Channel Index over a given period.
Definition: TSAFunctors.h:603
tsa::functor::lowest
min lowest
Typedef. Same as class max;.
Definition: TSAFunctors.h:99
tsa::functor::volatility
Functor for calculating Volatitity over a given period.
Definition: TSAFunctors.h:572
tsa::functor::chaikin_volatility
Definition: TSAFunctors.h:366
tsa::functor::stochastic
Functor for calculating Stochastic indicator over a given period.
Definition: TSAFunctors.h:498
tsa::functor::EMA
average_exp EMA
Typedef. Save as class functor::average_exp.
Definition: TSAFunctors.h:265
tsa::average
double average(const series< double > &data, size_t period)
Returns the the average value of data with given period.
Definition: TSAFunctionsScalar.cpp:98
tsa::series_cref< double >
tsa::functor::on_balance_volume
Definition: TSAFunctors.h:680
tsa::up
Rounds up to next higher multiple of minimum-tick.
Definition: TSAGlobal.h:29
tsa::series_cref::size_ok
bool size_ok(size_t sz) const
Definition: TSASeriesTemplate.h:1335
tsa::functor::sum_pos
Functor for calculating the sum of all positive values in a series over a given period.
Definition: TSAFunctors.h:157
tsa::functor::relative_volatility
Relative Volatility by Dorsey.
Definition: TSAFunctors.h:666
tsa::MIN
sref< double > MIN(const container &c)
Returns the minimum current values of all series in given container c.
Definition: TSADSLMath.cpp:667
tsa::date_time
Class representing a gregorian-date and time-of-day combination. The time component has microsecond r...
Definition: TSATime.h:428
tsa::functor::vortex_indicator
Vortex Indicator by Botes / Siepman.
Definition: TSAFunctors.h:645
tsa::functor::aroon
Definition: TSAFunctors.h:697
tsa::functor::variance
Functor for calculating the population standard deviation of all values in a series over a given peri...
Definition: TSAFunctors.h:273
tsa::functor::max
Functor for calculating the maximum value in a series over a given period.
Definition: TSAFunctors.h:42