QPair<int,double> ConnectivityMeasures::calcCrossCorrelation(const RowVectorXd& vecFirst, const RowVectorXd& vecSecond)
{
Eigen::FFT<double> fft;
int N = std::max(vecFirst.cols(), vecSecond.cols());
//Compute the FFT size as the "next power of 2" of the input vector's length (max)
int b = ceil(log2(2.0 * N - 1));
int fftsize = pow(2,b);
// int end = fftsize - 1;
// int maxlag = N - 1;
//Zero Padd
RowVectorXd xCorrInputVecFirst = RowVectorXd::Zero(fftsize);
xCorrInputVecFirst.head(vecFirst.cols()) = vecFirst;
RowVectorXd xCorrInputVecSecond = RowVectorXd::Zero(fftsize);
xCorrInputVecSecond.head(vecSecond.cols()) = vecSecond;
//FFT for freq domain to both vectors
RowVectorXcd freqvec;
RowVectorXcd freqvec2;
fft.fwd(freqvec, xCorrInputVecFirst);
fft.fwd(freqvec2, xCorrInputVecSecond);
//Create conjugate complex
freqvec2.conjugate();
//Main step of cross corr
for (int i = 0; i < fftsize; i++) {
freqvec[i] = freqvec[i] * freqvec2[i];
}
RowVectorXd result;
fft.inv(result, freqvec);
//Will get rid of extra zero padding
RowVectorXd result2 = result;//.segment(maxlag, N);
QPair<int,int> minMaxRange;
int idx = 0;
result2.minCoeff(&idx);
minMaxRange.first = idx;
result2.maxCoeff(&idx);
minMaxRange.second = idx;
// std::cout<<"result2(minMaxRange.first)"<<result2(minMaxRange.first)<<std::endl;
// std::cout<<"result2(minMaxRange.second)"<<result2(minMaxRange.second)<<std::endl;
// std::cout<<"b"<<b<<std::endl;
// std::cout<<"fftsize"<<fftsize<<std::endl;
// std::cout<<"end"<<end<<std::endl;
// std::cout<<"maxlag"<<maxlag<<std::endl;
//Return val
int resultIndex = minMaxRange.second;
double maxValue = result2(resultIndex);
return QPair<int,double>(resultIndex, maxValue);
}
QMap<int,QList<QPair<int,double> > > DetectTrigger::detectTriggerFlanksGrad(const MatrixXd& data, const QList<int>& lTriggerChannels, int iOffsetIndex, double dThreshold, bool bRemoveOffset, const QString& type, int iBurstLengthSamp)
{
QMap<int,QList<QPair<int,double> > > qMapDetectedTrigger;
RowVectorXd tGradient = RowVectorXd::Zero(data.cols());
//Find all triggers above threshold in the data block
for(int i = 0; i < lTriggerChannels.size(); ++i)
{
// QTime time;
// time.start();
int iChIdx = lTriggerChannels.at(i);
//Add empty list to map
QList<QPair<int,double> > temp;
qMapDetectedTrigger.insert(iChIdx, temp);
//detect the actual triggers in the current data matrix
if(iChIdx > data.rows() || iChIdx < 0)
{
return qMapDetectedTrigger;
}
//Compute gradient
for(int t = 1; t<tGradient.cols(); t++)
{
tGradient(t) = data(iChIdx,t)-data(iChIdx,t-1);
}
// If falling flanks are to be detected flip the gradient's sign
if(type == "Falling")
{
tGradient = tGradient * -1;
}
//Find positive maximum in gradient vector. This position is equal to the rising trigger flank.
for(int j = 0; j < tGradient.cols(); ++j)
{
double dMatVal = bRemoveOffset ? tGradient(j) - data(iChIdx,0) : tGradient(j);
if(dMatVal >= dThreshold)
{
QPair<int,double> pair;
pair.first = iOffsetIndex+j;
pair.second = tGradient(j);
qMapDetectedTrigger[iChIdx].append(pair);
j += iBurstLengthSamp;
}
}
// int timeElapsed = time.elapsed();
// std::cout<<"timeElapsed: "<<timeElapsed<<std::endl;
}
return qMapDetectedTrigger;
}
RowVectorXd DataPackage::cutData(const RowVectorXd &originalData, int cutFront, int cutBack)
{
if(originalData.cols()-cutFront-cutBack < 0 || cutFront>originalData.cols()) {
qDebug()<<"DataPackage::cutData - cutFront or cutBack do not fit. Aborting mapping and returning original data.";
RowVectorXd returnVec = originalData;
return returnVec;
}
//Cut original data using segment
return (RowVectorXd)originalData.segment(cutFront, originalData.cols()-cutFront-cutBack);
}
CDataObject::CDataObject(int total_pts, enumStreetIndices br_ndx, int times_acted, int ndealt, eBetType action_type) :
m_npoints(total_pts),
m_br(br_ndx),
m_nacted(times_acted),
m_ndealt(ndealt),
m_action(action_type)
{
assert(br_ndx >= ePreflopIndex && br_ndx < eRoundIndices);
assert(times_acted >= 0);
m_ndims = times_acted + (br_ndx == ePreflopIndex ? num_prior_dims_preflop : num_prior_dims_postflop) + 1;
// this is only used for ann
m_data = new double*[m_npoints];
// allocate hand_ids for corresponding data points
m_hand_ids = new long[m_npoints];
for(long i = 0; i < m_npoints; i++)
m_hand_ids[i] = -1L;
m_profits = VectorXd::Zero(m_npoints);
m_points = Matrix<double, Dynamic, Dynamic, RowMajor>::Zero(m_npoints, m_ndims);
CDatabase p_db;
GetData(&p_db);
// Set the weights
diag_factor = Matrix<double, Dynamic, Dynamic, RowMajor>::Identity(m_ndims, m_ndims);
#ifdef KASPER_WEIGHTS
RowVectorXd tmp;
if(ePreflopIndex == br_ndx)
{
tmp = RowVectorXd::Zero(9);
tmp << 10, 20, 100, 10, 0, 0, 2, 2, 20;
}
else
{
tmp = RowVectorXd::Zero(11);
tmp << 10, 80, 10, 0, 0, 0, 2, 2, 50, 1, 1;
}
diag_factor.bottomRightCorner(tmp.cols(), tmp.cols()) = tmp.asDiagonal();
#else
FeatureNormalize();
CRegressionObject regress(m_points, m_profits);
diag_factor = regress.get_theta().asDiagonal();
#endif
gLog.WriteLog(eSeverityInfo, eCatPerformance, "br%d_%d: %8s - %8d points\n", br_ndx+1, times_acted, bets_str[action_type], m_npoints);
}
QList<QPair<int,double> > DetectTrigger::detectTriggerFlanksGrad(const MatrixXd &data, int iTriggerChannelIdx, int iOffsetIndex, double dThreshold, bool bRemoveOffset, const QString& type, int iBurstLengthSamp)
{
QList<QPair<int,double> > lDetectedTriggers;
RowVectorXd tGradient = RowVectorXd::Zero(data.cols());
// QTime time;
// time.start();
//detect the actual triggers in the current data matrix
if(iTriggerChannelIdx > data.rows() || iTriggerChannelIdx < 0)
{
return lDetectedTriggers;
}
//Compute gradient
for(int t = 1; t < tGradient.cols(); ++t)
{
tGradient(t) = data(iTriggerChannelIdx,t) - data(iTriggerChannelIdx,t-1);
}
//If falling flanks are to be detected flip the gradient's sign
if(type == "Falling")
{
tGradient = tGradient * -1;
}
//Find all triggers above threshold in the data block
for(int j = 0; j < tGradient.cols(); ++j)
{
double dMatVal = bRemoveOffset ? tGradient(j) - data(iTriggerChannelIdx,0) : tGradient(j);
if(dMatVal >= dThreshold)
{
QPair<int,double> pair;
pair.first = iOffsetIndex+j;
pair.second = tGradient(j);
lDetectedTriggers.append(pair);
j += iBurstLengthSamp;
}
}
// int timeElapsed = time.elapsed();
// std::cout<<"timeElapsed: "<<timeElapsed<<std::endl;
return lDetectedTriggers;
}
VectorXd probutils::mahaldist (
const MatrixXd& X,
const RowVectorXd& mu,
const MatrixXd& A
)
{
// Check for same number of dimensions, D
if((X.cols() != mu.cols()) || (X.cols() != A.cols()))
throw invalid_argument("Arguments do not have the same dimensionality");
// Check if A is square
if (A.rows() != A.cols())
throw invalid_argument("Matrix A must be square!");
// Decompose A
LDLT<MatrixXd> Aldl(A);
// Check if A is PD
if ((Aldl.vectorD().array() <= 0).any() == true)
throw invalid_argument("Matrix A is not positive definite");
// Do the Mahalanobis distance for each sample (N times)
MatrixXd X_mu = (X.rowwise() - mu).transpose();
return ((X_mu.array() * (Aldl.solve(X_mu)).array())
.colwise().sum()).transpose();
}
RowVectorXd FilterData::applyFFTFilter(const RowVectorXd& data, bool keepOverhead, CompensateEdgeEffects compensateEdgeEffects) const
{
#ifdef EIGEN_FFTW_DEFAULT
fftw_make_planner_thread_safe();
#endif
if(data.cols()<m_dCoeffA.cols() && compensateEdgeEffects==MirrorData) {
qDebug()<<QString("Error in FilterData: Number of filter taps(%1) bigger then data size(%2). Not enough data to perform mirroring!").arg(m_dCoeffA.cols()).arg(data.cols());
return data;
}
// std::cout<<"m_iFFTlength: "<<m_iFFTlength<<std::endl;
// std::cout<<"2*m_dCoeffA.cols() + data.cols(): "<<2*m_dCoeffA.cols() + data.cols()<<std::endl;
if(2*m_dCoeffA.cols() + data.cols()>m_iFFTlength) {
qDebug()<<"Error in FilterData: Number of mirroring/zeropadding size plus data size is bigger then fft length!";
return data;
}
//Do zero padding or mirroring depending on user input
RowVectorXd t_dataZeroPad = RowVectorXd::Zero(m_iFFTlength);
switch(compensateEdgeEffects) {
case MirrorData:
t_dataZeroPad.head(m_dCoeffA.cols()) = data.head(m_dCoeffA.cols()).reverse(); //front
t_dataZeroPad.segment(m_dCoeffA.cols(), data.cols()) = data; //middle
t_dataZeroPad.tail(m_dCoeffA.cols()) = data.tail(m_dCoeffA.cols()).reverse(); //back
break;
case ZeroPad:
t_dataZeroPad.head(data.cols()) = data;
break;
default:
t_dataZeroPad.head(data.cols()) = data;
break;
}
//generate fft object
Eigen::FFT<double> fft;
fft.SetFlag(fft.HalfSpectrum);
//fft-transform data sequence
RowVectorXcd t_freqData;
fft.fwd(t_freqData,t_dataZeroPad);
//perform frequency-domain filtering
RowVectorXcd t_filteredFreq = m_dFFTCoeffA.array()*t_freqData.array();
//inverse-FFT
RowVectorXd t_filteredTime;
fft.inv(t_filteredTime,t_filteredFreq);
//Return filtered data
if(!keepOverhead)
return t_filteredTime.segment(m_dCoeffA.cols()/2, data.cols());
return t_filteredTime.head(data.cols()+m_dCoeffA.cols());
}
//target function przyjmuje macierz, wiec mozemy oba porownywane punkty polaczyc i przeslac.
bool NelderMead::Compare(RowVectorXd first, RowVectorXd second)
{
RowVector2d val;
MatrixXd temp(2, first.cols());
temp.row(0) = first;
temp.row(1) = second;
val = this->TargetFunction(temp);
return val[0] < val[1];
}
void DataPackage::setMappedProcData(const RowVectorXd &originalProcData, int row, int cutFront, int cutBack)
{
if(originalProcData.cols()-cutFront-cutBack != m_dataProcMapped.cols() || row >= m_dataProcMapped.rows()){
qDebug()<<"DataPackage::setMappedProcData - cannot set row data to m_dataProcOriginal";
return;
}
//Cut data
m_dataProcMapped.row(row) = cutData(originalProcData, cutFront, cutBack);
if(cutFront != m_iCutFrontProc)
m_iCutFrontProc = cutFront;
if(cutBack != m_iCutBackProc)
m_iCutBackProc = cutBack;
//Calculate mean
m_dataProcMean(row) = calculateRowMean(m_dataProcMapped.row(row));
}
RowVectorXd FilterData::applyConvFilter(const RowVectorXd& data, bool keepOverhead, CompensateEdgeEffects compensateEdgeEffects) const
{
if(data.cols()<m_dCoeffA.cols() && compensateEdgeEffects==MirrorData){
qDebug()<<QString("Error in FilterData: Number of filter taps(%1) bigger then data size(%2). Not enough data to perform mirroring!").arg(m_dCoeffA.cols()).arg(data.cols());
return data;
}
//Do zero padding or mirroring depending on user input
RowVectorXd t_dataZeroPad = RowVectorXd::Zero(2*m_dCoeffA.cols() + data.cols());
RowVectorXd t_filteredTime = RowVectorXd::Zero(2*m_dCoeffA.cols() + data.cols());
switch(compensateEdgeEffects) {
case MirrorData:
t_dataZeroPad.head(m_dCoeffA.cols()) = data.head(m_dCoeffA.cols()).reverse(); //front
t_dataZeroPad.segment(m_dCoeffA.cols(), data.cols()) = data; //middle
t_dataZeroPad.tail(m_dCoeffA.cols()) = data.tail(m_dCoeffA.cols()).reverse(); //back
break;
case ZeroPad:
t_dataZeroPad.segment(m_dCoeffA.cols(), data.cols()) = data;
break;
default:
t_dataZeroPad.segment(m_dCoeffA.cols(), data.cols()) = data;
break;
}
//Do the convolution
for(int i=m_dCoeffA.cols(); i<t_filteredTime.cols(); i++)
t_filteredTime(i-m_dCoeffA.cols()) = t_dataZeroPad.segment(i-m_dCoeffA.cols(),m_dCoeffA.cols()) * m_dCoeffA.transpose();
//Return filtered data
if(!keepOverhead)
return t_filteredTime.segment(m_dCoeffA.cols()/2, data.cols());
return t_filteredTime.head(data.cols()+m_dCoeffA.cols());
}
void DataPackage::setOrigRawData(const RowVectorXd &originalRawData, int row, int cutFront, int cutBack)
{
if(originalRawData.cols() != m_dataRawOriginal.cols() || row >= m_dataRawOriginal.rows()){
qDebug()<<"DataPackage::setOrigRawData - cannot set row data to m_dataRawOriginal";
return;
}
//set orignal data at row row
m_dataRawOriginal.row(row) = originalRawData;
//Cut data
m_dataRawMapped.row(row) = cutData(m_dataRawOriginal, cutFront, cutBack);
if(cutFront != m_iCutFrontRaw)
m_iCutFrontRaw = cutFront;
if(cutBack != m_iCutBackRaw)
m_iCutBackRaw = cutBack;
//Calculate mean
m_dataRawMean(row) = calculateRowMean(m_dataRawMapped.row(row));
}
