// select min weight edge
Graph SccGraph(const Graph &g) {
vector<vector<int> > scc = Scc(g);
const int n = g.size();
const int m = scc.size();
vector<int> mapto(n);
for (int i = 0; i < (int)scc.size(); i++) {
for (int j = 0; j < (int)scc[i].size(); j++) {
mapto[scc[i][j]] = i;
}
}
Graph ret(m);
vector<int> indexs(m, -1);
for (int from = 0; from < m; from++) {
int e = 0;
for (int i = 0; i < (int)scc[from].size(); i++) {
for (Edges::const_iterator it = g[scc[from][i]].begin(); it != g[scc[from][i]].end(); it++) {
int to = mapto[it->dest];
if (from == to) { continue; } // loopback
if (indexs[to] == -1) {
ret[from].push_back(Edge(from, to, it->weight));
indexs[to] = e++;
} else {
// select edge
ret[from][indexs[to]].weight = min(ret[from][indexs[to]].weight, it->weight);
}
}
}
for (Edges::const_iterator it = ret[from].begin(); it != ret[from].end(); it++) {
indexs[it->dest] = -1;
}
}
return ret;
}
bool LabelledRegressionData::spiltDataIntoKFolds(const UINT K){
crossValidationSetup = false;
crossValidationIndexs.clear();
//K can not be zero
if( K > totalNumSamples ){
errorLog << "spiltDataIntoKFolds(UINT K) - K can not be zero!" << endl;
return false;
}
//K can not be larger than the number of examples
if( K > totalNumSamples ){
errorLog << "spiltDataIntoKFolds(UINT K) - K can not be larger than the total number of samples in the dataset!" << endl;
return false;
}
//Setup the dataset for k-fold cross validation
kFoldValue = K;
vector< UINT > indexs( totalNumSamples );
//Work out how many samples are in each fold, the last fold might have more samples than the others
UINT numSamplesPerFold = (UINT) floor( totalNumSamples/double(K) );
//Add the random indexs to each fold
crossValidationIndexs.resize(K);
//Create the random partion indexs
Random random;
UINT randomIndex = 0;
//Randomize the order of the data
for(UINT i=0; i<totalNumSamples; i++) indexs[i] = i;
for(UINT x=0; x<totalNumSamples; x++){
//Pick a random index
randomIndex = random.getRandomNumberInt(0,totalNumSamples);
//Swap the indexs
SWAP( indexs[ x ] , indexs[ randomIndex ] );
}
UINT counter = 0;
UINT foldIndex = 0;
for(UINT i=0; i<totalNumSamples; i++){
//Add the index to the current fold
crossValidationIndexs[ foldIndex ].push_back( indexs[i] );
//Move to the next fold if ready
if( ++counter == numSamplesPerFold && foldIndex < K-1 ){
foldIndex++;
counter = 0;
}
}
crossValidationSetup = true;
return true;
}
UnlabelledClassificationData UnlabelledClassificationData::partition(UINT trainingSizePercentage){
//Partitions the dataset into a training dataset (which is kept by this instance of the UnlabelledClassificationData) and
//a testing/validation dataset (which is return as a new instance of the UnlabelledClassificationData). The trainingSizePercentage
//therefore sets the size of the data which remains in this instance and the remaining percentage of data is then added to
//the testing/validation dataset
//The dataset has changed so flag that any previous cross validation setup will now not work
crossValidationSetup = false;
crossValidationIndexs.clear();
const UINT numTrainingExamples = (UINT) floor( double(totalNumSamples) / 100.0 * double(trainingSizePercentage) );
UnlabelledClassificationData trainingSet(numDimensions);
UnlabelledClassificationData testSet(numDimensions);
vector< UINT > indexs( totalNumSamples );
//Create the random partion indexs
Random random;
UINT indexA = 0;
UINT indexB = 0;
UINT temp = 0;
for(UINT i=0; i<totalNumSamples; i++) indexs[i] = i;
for(UINT x=0; x<totalNumSamples*1000; x++){
//Pick two random indexs
indexA = random.getRandomNumberInt(0,totalNumSamples);
indexB = random.getRandomNumberInt(0,totalNumSamples);
//Swap the indexs
temp = indexs[ indexA ];
indexs[ indexA ] = indexs[ indexB ];
indexs[ indexB ] = temp;
}
//Add the data to the training and test sets
for(UINT i=0; i<numTrainingExamples; i++){
trainingSet.addSample( data.getRowVector( indexs[i] ) );
}
for(UINT i=numTrainingExamples; i<totalNumSamples; i++){
testSet.addSample( data.getRowVector( indexs[i] ) );
}
//Overwrite the training data in this instance with the training data of the trainingSet
data = trainingSet.getData();
totalNumSamples = trainingSet.getNumSamples();
return testSet;
}
int hIndex(vector<int>& citations) {
vector<int> indexs(citations.size() + 1, 0);
int n = citations.size();
for(auto c : citations) {
if(c > n)
indexs[n]++;
else
indexs[c]++;
}
int sum = n;
for(int i = 0; i < indexs.size(); i++) {
if(sum - indexs[i] <= i)
return i;
sum -= indexs[i];
}
return 0;
}
LabelledRegressionData LabelledRegressionData::partition(const UINT trainingSizePercentage){
//Partitions the dataset into a training dataset (which is kept by this instance of the LabelledRegressionData) and
//a testing/validation dataset (which is return as a new instance of the LabelledRegressionData). The trainingSizePercentage
//therefore sets the size of the data which remains in this instance and the remaining percentage of data is then added to
//the testing/validation dataset
const UINT numTrainingExamples = (UINT) floor( double(totalNumSamples) / 100.0 * double(trainingSizePercentage) );
LabelledRegressionData trainingSet(numInputDimensions,numTargetDimensions);
LabelledRegressionData testSet(numInputDimensions,numTargetDimensions);
vector< UINT > indexs( totalNumSamples );
//Create the random partion indexs
Random random;
UINT randomIndex = 0;
for(UINT i=0; i<totalNumSamples; i++) indexs[i] = i;
for(UINT x=0; x<totalNumSamples; x++){
randomIndex = random.getRandomNumberInt(0,totalNumSamples);
SWAP( indexs[ x ] , indexs[ randomIndex ] );
}
//Add the data to the training and test sets
for(UINT i=0; i<numTrainingExamples; i++){
trainingSet.addSample( data[ indexs[i] ].getInputVector(), data[ indexs[i] ].getTargetVector() );
}
for(UINT i=numTrainingExamples; i<totalNumSamples; i++){
testSet.addSample( data[ indexs[i] ].getInputVector(), data[ indexs[i] ].getTargetVector() );
}
//Overwrite the training data in this instance with the training data of the trainingSet
data = trainingSet.getData();
totalNumSamples = trainingSet.getNumSamples();
//The dataset has changed so flag that any previous cross validation setup will now not work
crossValidationSetup = false;
crossValidationIndexs.clear();
return testSet;
}
int nthSuperUglyNumber(int n, vector<int>& primes) {
const int m = primes.size();
vector<int> v(n);
vector<int> indexs(m, 0);
vector<int> nexts(m);
v[0] = 1;
for (int i = 1; i < n; i++) {
int min_next = INT_MAX;
for (int j = 0; j < m; j++) {
nexts[j] = v[indexs[j]] * primes[j];
min_next = min(min_next, nexts[j]);
}
for (int j = 0; j < m; j++) {
if (min_next == nexts[j]) {
indexs[j]++;
}
}
v[i] = min_next;
}
return v[n-1];
}
int nthSuperUglyNumber(int n, vector<int>& primes) {
vector<int>ans(n,INT_MAX);
ans[0]=1;
if(n==1)
return 1;
int m=primes.size();
vector<int> indexs(m,1);
vector<int> factors(primes.begin(),primes.end());
for(int i=1;i<n;i++)
{
for(int j=0;j<m;j++)
ans[i]=min(ans[i],factors[j]);
for(int j=0;j<m;j++)
{
if(ans[i]==factors[j])
{
factors[j]=primes[j]*ans[indexs[j]];
indexs[j]++;
}
}
}
return ans[n-1];
}
bool TimeSeriesClassificationData::spiltDataIntoKFolds(const UINT K,const bool useStratifiedSampling){
crossValidationSetup = false;
crossValidationIndexs.clear();
//K can not be zero
if( K == 0 ){
errorLog << "spiltDataIntoKFolds(UINT K) - K can not be zero!" << std::endl;
return false;
}
//K can not be larger than the number of examples
if( K > totalNumSamples ){
errorLog << "spiltDataIntoKFolds(UINT K,bool useStratifiedSampling) - K can not be larger than the total number of samples in the dataset!" << std::endl;
return false;
}
//K can not be larger than the number of examples in a specific class if the stratified sampling option is true
if( useStratifiedSampling ){
for(UINT c=0; c<classTracker.size(); c++){
if( K > classTracker[c].counter ){
errorLog << "spiltDataIntoKFolds(UINT K,bool useStratifiedSampling) - K can not be larger than the number of samples in any given class!" << std::endl;
return false;
}
}
}
//Setup the dataset for k-fold cross validation
kFoldValue = K;
Vector< UINT > indexs( totalNumSamples );
//Work out how many samples are in each fold, the last fold might have more samples than the others
UINT numSamplesPerFold = (UINT) floor( totalNumSamples/Float(K) );
//Resize the cross validation indexs buffer
crossValidationIndexs.resize( K );
//Create the random partion indexs
Random random;
UINT randomIndex = 0;
if( useStratifiedSampling ){
//Break the data into seperate classes
Vector< Vector< UINT > > classData( getNumClasses() );
//Add the indexs to their respective classes
for(UINT i=0; i<totalNumSamples; i++){
classData[ getClassLabelIndexValue( data[i].getClassLabel() ) ].push_back( i );
}
//Randomize the order of the indexs in each of the class index buffers
for(UINT c=0; c<getNumClasses(); c++){
UINT numSamples = (UINT)classData[c].size();
for(UINT x=0; x<numSamples; x++){
//Pick a random index
randomIndex = random.getRandomNumberInt(0,numSamples);
//Swap the indexs
SWAP( classData[c][ x ] , classData[c][ randomIndex ] );
}
}
//Loop over each of the classes and add the data equally to each of the k folds until there is no data left
Vector< UINT >::iterator iter;
for(UINT c=0; c<getNumClasses(); c++){
iter = classData[ c ].begin();
UINT k = 0;
while( iter != classData[c].end() ){
crossValidationIndexs[ k ].push_back( *iter );
iter++;
k++;
k = k % K;
}
}
}else{
//Randomize the order of the data
for(UINT i=0; i<totalNumSamples; i++) indexs[i] = i;
for(UINT x=0; x<totalNumSamples; x++){
//Pick a random index
randomIndex = random.getRandomNumberInt(0,totalNumSamples);
//Swap the indexs
SWAP( indexs[ x ] , indexs[ randomIndex ] );
}
UINT counter = 0;
UINT foldIndex = 0;
for(UINT i=0; i<totalNumSamples; i++){
//Add the index to the current fold
crossValidationIndexs[ foldIndex ].push_back( indexs[i] );
//Move to the next fold if ready
if( ++counter == numSamplesPerFold && foldIndex < K-1 ){
foldIndex++;
counter = 0;
}
}
}
crossValidationSetup = true;
return true;
}
TimeSeriesClassificationData TimeSeriesClassificationData::split(const UINT trainingSizePercentage,const bool useStratifiedSampling){
//Partitions the dataset into a training dataset (which is kept by this instance of the TimeSeriesClassificationData) and
//a testing/validation dataset (which is return as a new instance of the TimeSeriesClassificationData). The trainingSizePercentage
//therefore sets the size of the data which remains in this instance and the remaining percentage of data is then added to
//the testing/validation dataset
//The dataset has changed so flag that any previous cross validation setup will now not work
crossValidationSetup = false;
crossValidationIndexs.clear();
TimeSeriesClassificationData trainingSet(numDimensions);
TimeSeriesClassificationData testSet(numDimensions);
trainingSet.setAllowNullGestureClass(allowNullGestureClass);
testSet.setAllowNullGestureClass(allowNullGestureClass);
Vector< UINT > indexs( totalNumSamples );
//Create the random partion indexs
Random random;
UINT randomIndex = 0;
if( useStratifiedSampling ){
//Break the data into seperate classes
Vector< Vector< UINT > > classData( getNumClasses() );
//Add the indexs to their respective classes
for(UINT i=0; i<totalNumSamples; i++){
classData[ getClassLabelIndexValue( data[i].getClassLabel() ) ].push_back( i );
}
//Randomize the order of the indexs in each of the class index buffers
for(UINT k=0; k<getNumClasses(); k++){
UINT numSamples = (UINT)classData[k].size();
for(UINT x=0; x<numSamples; x++){
//Pick a random index
randomIndex = random.getRandomNumberInt(0,numSamples);
//Swap the indexs
SWAP( classData[k][ x ] ,classData[k][ randomIndex ] );
}
}
//Loop over each class and add the data to the trainingSet and testSet
for(UINT k=0; k<getNumClasses(); k++){
UINT numTrainingExamples = (UINT) floor( Float(classData[k].size()) / 100.0 * Float(trainingSizePercentage) );
//Add the data to the training and test sets
for(UINT i=0; i<numTrainingExamples; i++){
trainingSet.addSample( data[ classData[k][i] ].getClassLabel(), data[ classData[k][i] ].getData() );
}
for(UINT i=numTrainingExamples; i<classData[k].size(); i++){
testSet.addSample( data[ classData[k][i] ].getClassLabel(), data[ classData[k][i] ].getData() );
}
}
//Overwrite the training data in this instance with the training data of the trainingSet
data = trainingSet.getClassificationData();
totalNumSamples = trainingSet.getNumSamples();
}else{
const UINT numTrainingExamples = (UINT) floor( Float(totalNumSamples) / 100.0 * Float(trainingSizePercentage) );
//Create the random partion indexs
Random random;
for(UINT i=0; i<totalNumSamples; i++) indexs[i] = i;
for(UINT x=0; x<totalNumSamples; x++){
//Pick a random index
randomIndex = random.getRandomNumberInt(0,totalNumSamples);
//Swap the indexs
SWAP( indexs[ x ] , indexs[ randomIndex ] );
}
//Add the data to the training and test sets
for(UINT i=0; i<numTrainingExamples; i++){
trainingSet.addSample( data[ indexs[i] ].getClassLabel(), data[ indexs[i] ].getData() );
}
for(UINT i=numTrainingExamples; i<totalNumSamples; i++){
testSet.addSample( data[ indexs[i] ].getClassLabel(), data[ indexs[i] ].getData() );
}
//Overwrite the training data in this instance with the training data of the trainingSet
data = trainingSet.getClassificationData();
totalNumSamples = trainingSet.getNumSamples();
}
return testSet;
}
ClassificationData ClassificationData::split(const UINT trainingSizePercentage,const bool useStratifiedSampling){
//Partitions the dataset into a training dataset (which is kept by this instance of the ClassificationData) and
//a testing/validation dataset (which is return as a new instance of the ClassificationData). The trainingSizePercentage
//therefore sets the size of the data which remains in this instance and the remaining percentage of data is then added to
//the testing/validation dataset
//The dataset has changed so flag that any previous cross validation setup will now not work
crossValidationSetup = false;
crossValidationIndexs.clear();
ClassificationData trainingSet(numDimensions);
ClassificationData testSet(numDimensions);
trainingSet.setAllowNullGestureClass( allowNullGestureClass );
testSet.setAllowNullGestureClass( allowNullGestureClass );
//Create the random partion indexs
Random random;
UINT randomIndex = 0;
UINT K = getNumClasses();
if( useStratifiedSampling ){
//Break the data into seperate classes
Vector< Vector< UINT > > classData( K );
//Add the indexs to their respective classes
for(UINT i=0; i<totalNumSamples; i++){
classData[ getClassLabelIndexValue( data[i].getClassLabel() ) ].push_back( i );
}
//Randomize the order of the indexs in each of the class index buffers
for(UINT k=0; k<K; k++){
std::random_shuffle(classData[k].begin(), classData[k].end());
}
//Reserve the memory
UINT numTrainingSamples = 0;
UINT numTestSamples = 0;
for(UINT k=0; k<K; k++){
UINT numTrainingExamples = (UINT) floor( Float(classData[k].size()) / 100.0 * Float(trainingSizePercentage) );
UINT numTestExamples = ((UINT)classData[k].size())-numTrainingExamples;
numTrainingSamples += numTrainingExamples;
numTestSamples += numTestExamples;
}
trainingSet.reserve( numTrainingSamples );
testSet.reserve( numTestSamples );
//Loop over each class and add the data to the trainingSet and testSet
for(UINT k=0; k<K; k++){
UINT numTrainingExamples = (UINT) floor( Float(classData[k].getSize()) / 100.0 * Float(trainingSizePercentage) );
//Add the data to the training and test sets
for(UINT i=0; i<numTrainingExamples; i++){
trainingSet.addSample( data[ classData[k][i] ].getClassLabel(), data[ classData[k][i] ].getSample() );
}
for(UINT i=numTrainingExamples; i<classData[k].getSize(); i++){
testSet.addSample( data[ classData[k][i] ].getClassLabel(), data[ classData[k][i] ].getSample() );
}
}
}else{
const UINT numTrainingExamples = (UINT) floor( Float(totalNumSamples) / 100.0 * Float(trainingSizePercentage) );
//Create the random partion indexs
UINT randomIndex = 0;
Vector< UINT > indexs( totalNumSamples );
for(UINT i=0; i<totalNumSamples; i++) indexs[i] = i;
std::random_shuffle(indexs.begin(), indexs.end());
//Reserve the memory
trainingSet.reserve( numTrainingExamples );
testSet.reserve( totalNumSamples-numTrainingExamples );
//Add the data to the training and test sets
for(UINT i=0; i<numTrainingExamples; i++){
trainingSet.addSample( data[ indexs[i] ].getClassLabel(), data[ indexs[i] ].getSample() );
}
for(UINT i=numTrainingExamples; i<totalNumSamples; i++){
testSet.addSample( data[ indexs[i] ].getClassLabel(), data[ indexs[i] ].getSample() );
}
}
//Overwrite the training data in this instance with the training data of the trainingSet
*this = trainingSet;
//Sort the class labels in this dataset
sortClassLabels();
//Sort the class labels of the test dataset
testSet.sortClassLabels();
return testSet;
}
