double probability(unsigned int r) const
{
if(r == classes()-1)
return 1.0/fac<double>(classes());
else
return static_cast<double>(r+1)/fac<double>(r+2);
}
double probability(unsigned int r) const
{
if(r == classes()-1)
return 1-fac<double>(d)/std::pow(d, static_cast<double>(d+classes()-2))*
stirling2<double>(d+classes()-2, d);
else
return fac<double>(d)/std::pow(d, static_cast<double>(d+r)) *
stirling2<double>(d+r-1, d-1);
}
double probability(unsigned int r) const
{
++r; // transform to 1 <= r <= 5
double result = range;
for(unsigned int i = 1; i < r; ++i)
result *= range-i;
return result / std::pow(range, static_cast<double>(classes())) *
stirling2<double>(classes(), r);
}
// Generates random instances.
// num: number of instances to be generated.
// dataSize: number of features to be generated.
// eSize: number of expected outputs.
// strLen: length of random strings generated.
// instances: input/output vector of instances
void genRandInsts( const int& num, const int& dataSize, const int& eSize,
const int& strLen, std::vector<Instance>& instances ){
std::shared_ptr<std::vector<std::string> > features(new std::vector<std::string>());
std::shared_ptr<std::vector<std::string> > classes(new std::vector<std::string>());
// Generate sudo names for features and classes
for( int i = 0; i < dataSize; ++i){
features->push_back(randS(strLen));
}
for( int i = 0; i < eSize; ++i){
classes->push_back(randS(strLen));
}
// Generate instances
for( int i = 0; i < num; ++i ){
// Generate sudo data for each instance
std::vector<double>* data = new std::vector<double>();
std::vector<double>* expected = new std::vector<double>();
for( int j = 0; j < dataSize; ++j ){
data->push_back(randD());
}
for( int j = 0; j < dataSize; ++j ){
expected->push_back(randD());
}
instances.push_back( Instance( randS(strLen), data, expected, features, classes ));
}
}
std::string get_single_class(SEXP x) {
SEXP klass = Rf_getAttrib(x, R_ClassSymbol);
if (!Rf_isNull(klass)) {
CharacterVector classes(klass);
return collapse_utf8(classes);
}
if (Rf_isMatrix(x)) {
return "matrix";
}
switch (TYPEOF(x)) {
case INTSXP:
return "integer";
case REALSXP :
return "numeric";
case LGLSXP:
return "logical";
case STRSXP:
return "character";
case VECSXP:
return "list";
default:
break;
}
// just call R to deal with other cases
// we could call R_data_class directly but we might get a "this is not part of the api"
klass = Rf_eval(Rf_lang2(Rf_install("class"), x), R_GlobalEnv);
return CHAR(STRING_ELT(klass,0));
}
void run(NumberGenerator f, Counter & count, int n) const
{
assert(f.min() == 0 &&
static_cast<unsigned int>(f.max()) == classes()-1);
for(int i = 0; i < n; ++i)
count(f());
}
void testCalculateSplitPoints()
{
// validation points below were verified in weka
int c[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0 };
vector<int> classes(c, c + 20);
vector<double> values;
for (unsigned int i = 0; i < classes.size(); i++)
{
values.push_back(i);
}
FayyadMdlDiscretizer uut;
// call this just to set up internal data structures
FayyadMdlDiscretizer::SplitPoints points = uut.calculateSplitPoints(classes, values);
CPPUNIT_ASSERT_EQUAL(1, (int)points.size());
CPPUNIT_ASSERT_EQUAL(7, points[0]);
int c2[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
std::vector<int> classes2(c2, c2 + 1000);
vector<double> values2;
for (unsigned int i = 0; i < classes2.size(); i++)
{
values2.push_back(i);
}
points = uut.calculateSplitPoints(classes2, values2);
CPPUNIT_ASSERT_EQUAL(3, (int)points.size());
CPPUNIT_ASSERT_EQUAL(85, points[0]);
CPPUNIT_ASSERT_EQUAL(729, points[1]);
CPPUNIT_ASSERT_EQUAL(848, points[2]);
}
void testFindBestSplitPoint()
{
int c[] = { 1, 1, 0, 0, 1 };
std::vector<int> classes(c, c + 5);
vector<double> values;
for (unsigned int i = 0; i < classes.size(); i++)
{
values.push_back(i);
}
FayyadMdlDiscretizer uut;
// call this just to set up internal data structures
uut.calculateSplitPoints(classes, values);
double gain;
ASSERT_DBL_EQL(1, uut._findBestSplitPoint(0, 5, gain));
ASSERT_DBL_EQL(0.970950594 - (2.0 * 0.0 + 3.0 * 0.918295834) / 5.0, gain);
ASSERT_DBL_EQL(0, uut._findBestSplitPoint(0, 2, gain));
ASSERT_DBL_EQL(0.0, gain);
ASSERT_DBL_EQL(1, uut._findBestSplitPoint(1, 2, gain));
ASSERT_DBL_EQL(1.0, gain);
ASSERT_DBL_EQL(3, uut._findBestSplitPoint(2, 3, gain));
ASSERT_DBL_EQL(0.918295834, gain);
}
double probability(unsigned int r) const
{
double p = beta-alpha;
if(r == classes()-1)
return std::pow(1-p, static_cast<double>(r));
else
return p * std::pow(1-p, static_cast<double>(r));
}
double probability(unsigned int r) const
{
assert(classes() == 4);
assert(m == (1<<25));
assert(n == 512);
static const double prob[] = { 0.368801577, 0.369035243, 0.183471182,
0.078691997 };
return prob[r];
}
void File::readClasses() {
hsize_t dims;
m_iOrder = readiOrder();
H5::Group group(openGroup( "dark" ));
H5::DataSet classes(group.openDataSet("classes"));
assert( classes.getSpace().getSimpleExtentNdims() == 1 );
classes.getSpace().getSimpleExtentDims (&dims);
m_classes.insert(m_classes.end(),dims,classEntry());
classes.read( &(m_classes[0]), m_classType );
}
void run(NumberGenerator f, Counter & count, int n) const
{
unsigned int range = f.max()+1;
assert(f.min() == 0 && range*range == classes());
for(int i = 0; i < n; ++i) {
int y1 = f();
int y2 = f();
count(y1 + range * y2);
}
}
Interaction::CommandResult* CCreateClass::create(Visualization::Item* /*source*/, Visualization::Item* target,
const QString& name, const QStringList& attributes)
{
auto pr = dynamic_cast<OOModel::Project*> (target->node());
OOModel::Class* cl = nullptr;
bool newModel = false;
if (pr)
{
cl = new OOModel::Class();
if (!name.isEmpty()) cl->setName(name);
// Set visibility
if (attributes.first() == "private" ) cl->setVisibility(OOModel::Visibility::PRIVATE);
else if (attributes.first() == "protected" ) cl->setVisibility(OOModel::Visibility::PROTECTED);
else if (attributes.first() == "public" ) cl->setVisibility(OOModel::Visibility::PUBLIC);
else cl->setVisibility(OOModel::Visibility::DEFAULT);
pr->beginModification("create class");
pr->classes()->append(cl);
pr->endModification();
}
else
{
newModel = true;
auto model = new Model::Model();
cl = dynamic_cast<OOModel::Class*> (model->createRoot("Class"));
cl->beginModification("set project name");
if (!name.isEmpty()) cl->setName(name);
// Set visibility
if (attributes.first() == "private" ) cl->setVisibility(OOModel::Visibility::PRIVATE);
else if (attributes.first() == "protected" ) cl->setVisibility(OOModel::Visibility::PROTECTED);
else if (attributes.first() == "public" ) cl->setVisibility(OOModel::Visibility::PUBLIC);
else cl->setVisibility(OOModel::Visibility::DEFAULT);
cl->endModification();
target->scene()->addTopLevelItem( new Visualization::RootItem(cl) );
target->scene()->listenToModel(model);
}
target->setUpdateNeeded(Visualization::Item::StandardUpdate);
if (newModel) target->scene()->addPostEventAction(new Interaction::SetCursorEvent(target->scene(), cl,
Interaction::SetCursorEvent::CursorDefault, true));
else target->scene()->addPostEventAction(new Interaction::SetCursorEvent(target, cl,
Interaction::SetCursorEvent::CursorDefault, true));
return new Interaction::CommandResult();
}
void run(UniformRandomNumberGenerator f, Counter & count, int n) const
{
typedef typename UniformRandomNumberGenerator::result_type result_type;
assert(std::numeric_limits<result_type>::is_integer);
assert(f.min() == 0);
assert(f.max() == static_cast<result_type>(range-1));
std::vector<result_type> v(classes());
for(int i = 0; i < n; ++i) {
for(unsigned int j = 0; j < classes(); ++j)
v[j] = f();
std::sort(v.begin(), v.end());
result_type prev = v[0];
int r = 1; // count different values in v
for(unsigned int i = 1; i < classes(); ++i) {
if(prev != v[i]) {
prev = v[i];
++r;
}
}
count(r-1);
}
}
void PrintToFiles()
{
::EnumWindows(enumWindowsProc, NULL);
std::string wnd;
std::string wndname;
std::ofstream names("window-names.txt");
for (auto &p : g_windows)
{
Nena::Converter::ToString(wnd, (UINT32) p.first);
wndname = p.second;
names << wnd.c_str() << " " << wndname << "\n";
OutputDebugStringA("-window: ");
OutputDebugStringA(wndname.c_str());
OutputDebugStringA("\n");
}
names.close();
std::ofstream images("window-images.txt");
for (auto &p : g_images)
{
Nena::Converter::ToString(wnd, (UINT32) p.first);
wndname = p.second;
images << wnd.c_str() << " " << wndname.c_str() << "\n";
OutputDebugStringA("-image: ");
OutputDebugStringA(wndname.c_str());
OutputDebugStringA("\n");
}
images.close();
std::ofstream classes("window-classes.txt");
for (auto &p : g_classes)
{
Nena::Converter::ToString(wnd, (UINT32) p.first);
wndname = p.second;
classes << wnd.c_str() << " " << wndname.c_str() << "\n";
OutputDebugStringA("-class: ");
OutputDebugStringA(wndname.c_str());
OutputDebugStringA("\n");
}
classes.close();
}
void File::writeClasses() {
H5::Group group(openGroup( "dark" ));
H5::DataSet classes(group.openDataSet("classes"));
assert( classes.getSpace().getSimpleExtentNdims() == 1 );
hsize_t dataSize = m_classes.size();
hsize_t Zero = 0;
H5::DataSpace spaceDisk(1,&dataSize);
H5::DataSpace spaceMem(1,&dataSize);
classes.extend(&dataSize);
spaceDisk.selectHyperslab(H5S_SELECT_SET,&dataSize,&Zero);
spaceMem.selectHyperslab(H5S_SELECT_SET,&dataSize,&Zero);
classes.write( &(m_classes[0]), m_classType, spaceMem, spaceDisk );
//classes.flush(H5F_SCOPE_LOCAL);
}
void run(NumberGenerator & f, Counter & count, int n) const
{
typedef typename NumberGenerator::result_type result_type;
unsigned int length = 0;
for(int i = 0; i < n; ) {
result_type value = f();
if(value < low || value > high)
++length;
else {
count((std::min)(length, classes()-1));
length = 0;
++i;
}
}
}
void UnterfacePass::run_pass(DexClassesVector& dexen, ConfigFiles& cfg) {
Scope scope = build_class_scope(dexen);
InterfaceImplementations interfaces(scope);
assert(interfaces.print_all());
auto one_level = exclude(interfaces,
HAS_SUPER | HAS_CHILDREN | NO_VMETHODS,
IMPL_MULTIPLE_INTERFACES |
HAS_SUPER |
HAS_CHILDREN |
IS_ABSTRACT |
NO_MATCH_INTERFACE_METHODS |
HAS_MULTIPLE_INSTANCE_FIELDS |
MULTIPLE_ARGS_CTOR |
HAS_CLINIT |
NO_VMETHODS |
HAS_STATIC_FIELDS |
HAS_DIRECT_METHODS);
interfaces.analyze_candidates(one_level, "No hierarchy, perfect match");
// optimize
std::vector<DexClass*> untfs;
std::unordered_set<DexClass*> removed;
//optimize(scope, candidates, untfs, removed);
// write back
DexClassesVector outdex;
DexClasses& orig_classes = dexen[0];
DexClasses classes(orig_classes.size() + untfs.size() - removed.size());
int pos = 0;
for (int i = 0; i < orig_classes.size(); ++i) {
auto cls = orig_classes.get(i);
if (removed.find(cls) == removed.end()) {
classes.insert_at(cls, pos++);
}
}
for (auto untf : untfs) {
classes.insert_at(untf, pos++);
}
outdex.emplace_back(std::move(classes));
for (size_t i = 1; i < dexen.size(); i++) {
outdex.emplace_back(std::move(dexen[i]));
}
dexen = std::move(outdex);
}
void run(UniformRandomNumberGenerator f, Counter & count, int n) const
{
typedef typename UniformRandomNumberGenerator::result_type result_type;
double range = f.max() - f.min() + 1.0;
result_type low = static_cast<result_type>(alpha * range);
result_type high = static_cast<result_type>(beta * range);
unsigned int length = 0;
for(int i = 0; i < n; ) {
result_type value = f() - f.min();
if(value < low || value > high)
++length;
else {
count(std::min(length, classes()-1));
length = 0;
++i;
}
}
}
Model::Node* Project::navigateTo(Model::Node* source, QString path)
{
QString symbol = extractFrontSymbol(path);
Model::Node* found = nullptr;
// Is the target symbol name the module's name
if (isAncestorOf(source) && symbol == symbolName()) found = this;
if (!found) found = projects()->findFirstSymbolDefinition(symbol);
if (!found) found = libraries()->findFirstSymbolDefinition(symbol);
if (!found) found = modules()->findFirstSymbolDefinition(symbol);
if (!found) found = classes()->findFirstSymbolDefinition(symbol);
if (!found) return ExtendableNode::navigateTo(source, path);
QString rest = extractSecondaryPath(path);
if (!rest.isEmpty()) return found->navigateTo(this, rest);
else return found;
}
// Returns in gens a generating set for Zm* /<p>, and in ords the
// order of these generators. Return value is the order of p in Zm*.
long findGenerators(vector<long>& gens, vector<long>& ords, long m, long p)
{
gens.clear();
ords.clear();
// Compute the generators for (Z/mZ)^*
vector<long> classes(m);
vector<long> orders(m);
for (long i=0; i<m; i++) { // initially each element in its own class
if (GCD(i,m)!=1) classes[i] = 0; // i is not in (Z/mZ)^*
else classes[i] = i;
}
// Start building a representation of (Z/mZ)^*, first use the generator p
conjClasses(classes,p % m,m); // merge classes that have a factor of p
// The order of p is the size of the equivalence class of 1
#if 0
long ordP = std::count(classes.begin(), classes.end(), 1);
// count(from,to,val) returns # of elements in (from,to) with value=val
#else
long ordP = 0;
for (long i = 0; i < lsize(classes); i++)
if (classes[i] == 1) ordP++;
#endif
// Compute orders in (Z/mZ)^*/<p> while comparing to (Z/mZ)^*
while (true) {
compOrder(orders,classes,true,m);
// if the orders of i in Zm* /<p> and Zm* are not the same, then
// order[i] contains the order in Zm* /<p> with negative sign
long idx = argmax(orders, >AbsVal); // find the element with largest order
long largest = orders[idx];
if (abs(largest) == 1) break; // Trivial group, we are done
// store generator with same order as in (Z/mZ)^*
gens.push_back(idx);
ords.push_back(largest);
conjClasses(classes,idx,m); // merge classes that have a factor of idx
}
return ordP;
}
DexClasses DexLoader::load_dex(const char* location, dex_stats_t* stats) {
m_file.open(location, boost::iostreams::mapped_file::readonly);
if (!m_file.is_open()) {
fprintf(stderr, "error: cannot create memory-mapped file: %s\n", location);
exit(EXIT_FAILURE);
}
auto dh = reinterpret_cast<const dex_header*>(m_file.const_data());
validate_dex_header(dh, m_file.size());
if (dh->class_defs_size == 0) {
return DexClasses(0);
}
m_idx = new DexIdx(dh);
auto off = (uint64_t)dh->class_defs_off;
auto limit = off + dh->class_defs_size * sizeof(dex_class_def);
always_assert_log(off < m_file.size(), "class_defs_off out of range");
always_assert_log(limit <= m_file.size(), "invalid class_defs_size");
m_class_defs =
reinterpret_cast<const dex_class_def*>(m_file.const_data() + off);
DexClasses classes(dh->class_defs_size);
m_classes = &classes;
auto lwork = new class_load_work[dh->class_defs_size];
auto wq =
workqueue_mapreduce<class_load_work*, std::vector<std::exception_ptr>>(
class_work, exc_reducer);
for (uint32_t i = 0; i < dh->class_defs_size; i++) {
lwork[i].dl = this;
lwork[i].num = i;
wq.add_item(&lwork[i]);
}
const auto exceptions = wq.run_all();
delete[] lwork;
if (!exceptions.empty()) {
// At least one of the workers raised an exception
aggregate_exception ae(exceptions);
throw ae;
}
gather_input_stats(stats, dh);
return classes;
}
void run(UniformRandomNumberGenerator f, Counter & count, int n) const
{
typedef typename UniformRandomNumberGenerator::result_type result_type;
result_type init = (up ? f.min() : f.max());
result_type previous = init;
unsigned int length = 0;
for(int i = 0; i < n; ++i) {
result_type val = f();
if(up ? previous <= val : previous >= val) {
previous = val;
++length;
} else {
count(std::min(length, classes())-1);
length = 0;
previous = init;
// don't use this value, so that runs are independent
}
}
}
void testDelta()
{
int c[] = { 1, 1, 0, 0, 1 };
std::vector<int> classes(c, c + 5);
vector<double> values;
for (unsigned int i = 0; i < classes.size(); i++)
{
values.push_back(i);
}
FayyadMdlDiscretizer uut;
// call this just to set up internal data structures
uut.calculateSplitPoints(classes, values);
// calculate it manually
double k = 2, k1 = 1, k2 = 2;
double ent = 0.970950594, entLeft = 0.0, entRight = 0.918295834;
double delta = log(pow(3.0, k) - 2) / log(2.0) -
(k * ent - k1 * entLeft - k2 * entRight);
ASSERT_DBL_EQL(delta, uut._calculateDelta(0, 5, 1));
}
void JNICALL OnVMInit(jvmtiEnv *jvmti, JNIEnv *jniEnv, jthread thread) {
IMPLICITLY_USE(thread);
TimeUtils::init(); // required to init OS X's clock service
// Forces the creation of jmethodIDs of the classes that had already
// been loaded (eg java.lang.Object, java.lang.ClassLoader) and
// OnClassPrepare() misses.
jint class_count;
JvmtiScopedPtr<jclass> classes(jvmti);
JVMTI_ERROR((jvmti->GetLoadedClasses(&class_count, classes.GetRef())));
jclass *classList = classes.Get();
for (int i = 0; i < class_count; ++i) {
jclass klass = classList[i];
CreateJMethodIDsForClass(jvmti, klass);
}
if (!configuration.host.empty() && !configuration.port.empty()) {
controller->start();
}
}
void trainMulticlassSvm(CvSVM& classifier, Mat trainingFeatures, vector<int> classLabels, int kFolds)
{
/* Model parameters */
CvSVMParams params;
params.kernel_type = CvSVM::LINEAR;
params.svm_type = CvSVM::C_SVC;
/* Leave-one-out or k-folds crossvalidation? */
if (kFolds <= 0) {
kFolds = trainingFeatures.rows;
}
/* The SVM wants class labels as floats (weird) */
Mat classes(classLabels.size(), 1, CV_32FC1);
for (size_t i = 0; i < classLabels.size(); i++) {
classes.at<float>(i, 0) = classLabels[i];
}
/* Now train the shit out of it */
classifier.train_auto(trainingFeatures, classes, Mat(), Mat(), params, kFolds);
}
void testEntropy()
{
int c[] = { 1, 1, 0, 0, 1 };
std::vector<int> classes(c, c + 5);
vector<double> values;
for (unsigned int i = 0; i < classes.size(); i++)
{
values.push_back(i);
}
FayyadMdlDiscretizer uut;
// call this just to set up internal data structures
uut.calculateSplitPoints(classes, values);
ASSERT_DBL_EQL(0.970950594, uut._calculateEntropy(0, 5));
ASSERT_DBL_EQL(0, uut._calculateEntropy(0, 2));
ASSERT_DBL_EQL(0, uut._calculateEntropy(0, 0));
ASSERT_DBL_EQL(0, uut._calculateEntropy(0, 1));
ASSERT_DBL_EQL(1.0, uut._calculateEntropy(0, 4));
ASSERT_DBL_EQL(1.0, uut._calculateEntropy(1, 4));
ASSERT_DBL_EQL(0.918295834, uut._calculateEntropy(2, 3));
}
int display_net(list<string>::iterator &ifname,
bool signd, bool load, list<string> *mats) {
// create network
idx<ubyte> classes(1,1);
load_matrix<ubyte>(classes, conf->get_cstring("classes"));
answer_module<T,T,T> *answer = create_answer<T,T,T>(*conf, classes.dim(0));
if (!answer) eblerror("no answer module found");
uint noutputs = answer->get_nfeatures();
parameter<T> theparam;
intg thick;
module_1_1<T> *net = create_network<T>(theparam, *conf, thick, noutputs);
cout << "Network parameters: " << theparam << endl;
vector<string> weights =
string_to_stringvector(conf->get_string("weights_file"));
// loading weights
theparam.load_x(weights);
// displaying internals
uint h0 = 0, w0 = 0;
#ifdef __GUI__
disable_window_updates();
clear_window();
if (show_filename) {
gui << at(h0, w0) << black_on_white() << ifname->c_str();
h0 += 16;
}
if (autorange) // automatic range
lg.display_internals(*net, h0, w0, zoom, (T) 0, (T) 0, maxwidth);
else // fixed range
lg.display_internals(*net, h0, w0, zoom, (T) range[0], (T) range[1],
maxwidth);
// update title
string title;
title << "matshow: " << ebl::basename(ifname->c_str());
set_window_title(title.c_str());
enable_window_updates();
#endif
return 1;
}
static int skip_white()
{
/**************************************
*
* s k i p _ w h i t e
*
**************************************
*
* Functional description
* Skip over white space and comments in input stream
*
**************************************/
SSHORT c;
while ((c = nextchar()) != EOF) {
const SSHORT char_class = classes(c);
if (char_class & CHR_white)
continue;
if (c == '/') {
SSHORT next = nextchar();
if (next != '*') {
retchar(next);
return c;
}
c = nextchar();
while ((next = nextchar()) &&
(next != EOF) && !(c == '*' && next == '/'))
{
c = next;
}
continue;
}
break;
}
return c;
}
void run(NumberGenerator & f, Counter & count, int n) const
{
typedef typename NumberGenerator::result_type result_type;
result_type init =
runs_direction_helper<
up,
!std::numeric_limits<result_type>::is_integer
>::init(result_type());
result_type previous = init;
unsigned int length = 0;
for(int i = 0; i < n; ++i) {
result_type val = f();
if(up ? previous <= val : previous >= val) {
previous = val;
++length;
} else {
count((std::min)(length, classes())-1);
length = 0;
previous = init;
// don't use this value, so that runs are independent
}
}
}
