Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,14 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+WISDM-dataset-description.pdf filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/WISDM-dataset-description.pdf filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/bin/magic filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/bin/arffmagic filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/bin/arffmagic.dSYM/Contents/Resources/DWARF/arffmagic filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/build/main.o filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/build/write.o filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/build/funcmap.o filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/build/arff.o filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/build/attribute.o filter=lfs diff=lfs merge=lfs -text
+wisdm-dataset/arffmagic-master/build/read.o filter=lfs diff=lfs merge=lfs -text

WISDM-dataset-description.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d378fb33f871714cf2b1fbec65bab7eeed93e1892fc1460d80e45c022ce92ba
+size 578662

wisdm-dataset/README.txt

@@ -0,0 +1,107 @@
+This dataset includes activity data from 51 participants from an activity
+recognition project. Each participant performed each of the 18 activities 
+(listed in activity_key.txt) for 3 minutes and the sensor data (accelerometer 
+and gyroscope for smartphone and smartwatch) was recorded at a rate of 20 Hz. 
+The smartphones used were Nexus 5, Nexus 5X, and Galaxy S6 while the smartwatch
+used was the LG G watch. This dataset contains the raw data as well as the
+transformed data which was generated using arffmagic (located in
+arffmagic-master).
+
+A much more detailed description of the two main data sets is provided in the
+wisdm-dataset-description.pdf document at the top level of the data directory.
+
+################################################################################
+################################################################################
+
+The raw sensor data is located in the raw directory. Each user has its own data
+file which is tagged with their subject id, the sensor, and the device.  Within
+the data file, each line is:
+
+Subject-id, Activity Label, Timestamp, x, y, z
+
+The features are defined as follows:
+
+subject-id: Identfies the subject and is an integer value between 1600 and 1650.
+
+activity-label: see activity_key.txt for a mapping from 18 characters to the
+       activity name
+
+timestamp: time that the reading was taken (Unix Time)
+
+x: x sensor value (real valued) 
+y: y sensor value (real valued) 
+z: z sensor value (real valued) 
+
+################################################################################
+################################################################################
+
+ARFF files for each user (with attributes described below) are located in the 
+arff_files directory. The ARFF files are created using the arffmagic program, which
+aggregates the lower level raw data into examples labeled with the activity being
+performed. The descriptions of these features are also found in the many WISDM
+activity recognition papers. 
+
+Recognize that the sensors are samples at 20Hz and we use a 10 second window size,
+so most of the statistics are based on the aggregation of 200 sensor readings.
+
+Attribute information:
+ACTIVITY[1]:
+	This field contains the code that uniquely identifies the activity
+	(activity_key.txt provides the mapping from code to actual activity)
+
+Binned Distribution[30]:
+	The range of values is determined (maximum - minimum), 10 equal-sized
+	bins are formed, and the fraction of the 200 values within each bin
+	is recorded for each of the 3 axes. The axis bin values are provided
+	in the following order: x, y, z (10 values for each). The attributes are
+	named X0 .. X9, Y1 ... Y9, and Z0 ... Z9
+
+Average[3]:
+	 Average sensor value (for each of the 3 axes). Labeled XAVG, YAVG, ZAVG
+
+
+Time Between Peaks[3]:
+	Time between peaks in the sinusoidal waves formed by the data
+	as determined by a simple algorithm (feel free to check the code). Done
+	for each axis). Labeled XPEAK, YPEAK, ZPEAK.
+
+Average Absolute Difference[3]:
+	Average absolute difference between the 200 values and the mean of these
+	values (for each axis). Labeled as {X,Y,Z}ABSOLDEV
+
+Standard Deviation[3]:
+	 Standard deviation (for each axis). Labeled as {X,Y,Z}STANDDEV
+
+Variance[3];
+	The variance of the values (for each axis). Labeled as {X,Y,Z}VAR
+
+--------------------------------------------------------------------------------
+THE NEXT THREE SETS OF FEATURES ARE NOT USED IN OUR PUBLISHED RESEARCH PAPERS. THEY 
+WERE ADDED TO EXPERIMENT WITH.  
+
+MFCC: Mel-frequency cepstral coefficients [39]
+	MFCCs are a representation of the short-term power spectrum of a wave, based
+	on a linear cosine transform of a log power spectrum on a nonlinear mel scale
+	of frequency. There are 13 per axis There are 13 per axis. They are labeled as
+	XMFCC{0-12}, YMFCC{0-12}, and ZMFCC{0-12}. 
+
+
+Cosine distance [3]:
+	These are the cosine distances between the sensor values for a pair of axes.
+	Three pairs are considered to cover all possible pairs. They are labeled as
+	{XY, XZ, YZ}COS.
+
+Correlation [3]:
+	These are the correlations between the sensor values for a pair of axes.
+	Three pairs are considered to cover all possible pairs. They are labeled as
+	{XY, XZ, YZ}COR.
+
+----------------------------------------------------------------------------------
+
+Average Resultant Acceleration[1]:
+	For each of the sensor samples in the window, take the square root of the sum
+	of the square of the x, y, z axis values, and then average them. Labeled as
+	RESULTANT.
+
+class: Subject-id (this name is misleading since for activity recognition the class is
+	the activity in the first position).  

wisdm-dataset/WISDM-dataset-description.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d378fb33f871714cf2b1fbec65bab7eeed93e1892fc1460d80e45c022ce92ba
+size 578662

wisdm-dataset/activity_key.txt

@@ -0,0 +1,19 @@
+walking = A
+jogging = B
+stairs = C
+sitting = D
+standing = E
+typing = F
+teeth = G
+soup = H
+chips = I
+pasta = J
+drinking = K
+sandwich = L
+kicking = M
+catch = O
+dribbling = P
+writing = Q
+clapping = R
+folding = S
+

wisdm-dataset/arffmagic-master/Makefile

@@ -0,0 +1,33 @@
+SHELL=/bin/sh
+SRC=./src
+BIN=./bin
+BUILD=./build
+CC=clang++
+CFLAGS=-std=c++11 -g -O2 -Wall -Wextra
+LDFLAGS=-lAquila -lgsl -lgslcblas -lm
+EXE=$(BIN)/arffmagic
+OBJS=$(BUILD)/main.o $(BUILD)/globals.o $(BUILD)/raw.o $(BUILD)/read.o $(BUILD)/chunk.o $(BUILD)/write.o $(BUILD)/arff.o $(BUILD)/funcmap.o $(BUILD)/attribute.o $(BUILD)/libmfcc.o
+DS:=dsymutil
+DSYM=$(BIN)/arffmagic.dSYM
+.SUFFIXES: 
+.SUFFIXES: .c .cpp .o
+
+dsym: $(DSYM)
+	
+all: $(EXE) $(DSYM)
+
+$(EXE): $(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJS)
+
+$(BUILD)/%.o: $(SRC)/%.cpp
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(BUILD)/%.o: $(SRC)/%.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(DSYM): $(EXE)
+	$(DS) -o $@ $<
+
+.PHONY: clean
+clean: 
+	rm -rf $(OBJS) $(EXE) $(DSYM)

wisdm-dataset/arffmagic-master/README.md

@@ -0,0 +1 @@
+# arffmagic

wisdm-dataset/arffmagic-master/bin/arffmagic

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d86e4bec8ba5f1921699e3c25e1e8a819359394245b7d82d9f29740b1169bf46
+size 140780

wisdm-dataset/arffmagic-master/bin/arffmagic.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.arffmagic</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

wisdm-dataset/arffmagic-master/bin/arffmagic.dSYM/Contents/Resources/DWARF/arffmagic

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa607d022fc8bb9f8e728f7040f17b60fbdc7213e1bfce2f1a34bfcce4d6499a
+size 1009535

wisdm-dataset/arffmagic-master/bin/magic

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7be816dcfe583ef221b915067a586f6b9a9070c4e70db54624dc57d11d2c48e4
+size 178012

wisdm-dataset/arffmagic-master/build/arff.o

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78afa782cbcd22def496861ea5cf1708f4bf813dd70951d0645366723f692021
+size 325072

wisdm-dataset/arffmagic-master/build/attribute.o

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:432dc51dd3b83c2d6eee0b771140980a27c2b175757b922663ae493787246487
+size 184192

wisdm-dataset/arffmagic-master/build/funcmap.o

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40d7c59c69a7c6c6cd01253918cce6003495be7a3384c17fe13bff61f322089b
+size 270328

wisdm-dataset/arffmagic-master/build/main.o

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c745f17f3a095ce5cef1a26831c726f1079e5feef30958f4a0cff245682e5b1d
+size 184100

wisdm-dataset/arffmagic-master/build/read.o

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc608089eb9372a55e1f6e8e7cc5df012f2cf1e308e86609c41cbdc16da5c081
+size 173244

wisdm-dataset/arffmagic-master/build/write.o

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:508563dda17896a97f5c433a8a0392362440e832c387448110f313640acf355d
+size 401100

wisdm-dataset/arffmagic-master/src/arff.cpp

@@ -0,0 +1,40 @@
+#include "arff.h"
+#include "try.h"
+using std::endl;
+
+arff::arff (char ** argv, void(* init)(arff&), void(* translate)(arff&)): container(new funcmap), relation("") {
+    tryOrDie([this, &argv]() { openFiles(argv); });
+    init(*this);
+    arfStream << "@relation " << relation << endl << endl;
+    translate(*this);
+    container->writeHeader(arfStream);
+    arfStream << "@data" << endl << instanceStream.str();
+    std::cout << "magic @ " << argv[2] << endl;
+}
+
+arff::~arff () {
+    delete container;
+    rawStream.close();
+    arfStream.close();
+}
+
+void arff::openFiles (char ** argv) throw (OpenFileFail) {
+    rawStream.open(argv[1]);
+    if (!rawStream.is_open()) {
+        throw OpenFileFail(argv[1]);
+    } else {
+        arfStream.open(argv[2]);
+        if (!arfStream.is_open()) {
+            throw OpenFileFail(argv[2]);
+        }
+    }
+}
+
+void arff::add (int position, void(*calc)(const std::unique_ptr<attribute>&), std::string name, std::string type) {
+    container->push(position, name, type, calc);
+}
+
+void arff::compute () {
+    container->hash();
+    instanceStream << container << endl;
+}

wisdm-dataset/arffmagic-master/src/arff.h

@@ -0,0 +1,25 @@
+#ifndef ARFF_H
+#define ARFF_H
+#include <sstream>
+#include <fstream>
+#include <string>
+#include "funcmap.h"
+#include "except.h"
+
+class arff {
+public:
+    arff  (char **, void(*)(arff&), void(*)(arff&));
+    ~arff ();
+    void add (int, void(*)(const std::unique_ptr<attribute>&), std::string, std::string = "numeric");
+    void setRelation (std::string _relation) { relation=_relation; }
+    void compute ();
+    std::ifstream rawStream;
+private:
+    void openFiles (char **) throw (OpenFileFail);
+    funcmap * container;
+    std::string relation;
+    std::ofstream arfStream;
+    std::stringstream instanceStream;
+};
+
+#endif

wisdm-dataset/arffmagic-master/src/attribute.cpp

@@ -0,0 +1,47 @@
+#include "attribute.h"
+
+bool attribute::spaceFound (string str) {
+    unsigned long i = 0; bool space = false;
+    while (!space && i<str.length()) {
+        space = isspace(str[i]);
+        i++;
+    } return space;
+}
+
+string attribute::representStr (string str) {
+    string newstr = str;
+    if (spaceFound(str)) {
+        newstr = "\"";
+        newstr += (str += "\"");
+    } return newstr;
+}
+
+string nominal::representType (string str) {
+    string newstr = "{ ";
+    newstr += (str += " }");
+    return newstr;
+}
+
+void nominal::set (string str) {
+    val = representStr(str);
+    if (types.empty()) {
+        types.push_back(val);
+        type += val;
+    } else if ((std::find(types.begin(), types.end(), val)) == types.end()) {
+        types.push_back(val);
+        type += ", ";
+        type += val;
+    }
+}
+
+void numeric::print (std::ofstream& strm) const { strm << val; }
+void numeric::print (std:: ostream& strm) const { strm << val; }
+void nominal::print (std::ofstream& strm) const { strm << val; }
+void nominal::print (std:: ostream& strm) const { strm << val; }
+void stringy::print (std::ofstream& strm) const { strm << val; }
+void stringy::print (std:: ostream& strm) const { strm << val; }
+
+attribute::~attribute () {};
+numeric::~numeric () {};
+nominal::~nominal () {};
+stringy::~stringy () {};

wisdm-dataset/arffmagic-master/src/attribute.h

@@ -0,0 +1,67 @@
+#ifndef ATTRIBUTE_H
+#define ATTRIBUTE_H
+#include <algorithm>
+#include <fstream>
+#include <vector>
+#include <memory>
+using std::string;
+
+class attribute {
+public:
+    attribute (int _position, string _name, string _type): position(_position), name(_name), type(_type), title("@attribute") {};
+    virtual ~attribute ();
+    string declare () { 
+        return (this->title + " \"" + this->name + "\" " + this->representType(this->type)); 
+    }
+    const int position;
+    string name;
+    string type;
+    const string title;
+    bool spaceFound (string);
+    string representStr (string);
+    virtual string representType (string str) { return str; }
+    virtual void set (double) {};
+    virtual void set (string) {};
+    virtual void setType (std::vector<const char *>) {};
+    virtual void print (std::ofstream&) const=0;
+    virtual void print (std:: ostream&) const=0;
+    template <typename stream>
+    friend stream& operator << (stream& strm, const std::unique_ptr<attribute>& attr){
+        attr->print(strm);
+        return strm;
+    }
+};
+
+class numeric: public attribute {
+public:
+    double val;
+    numeric (int _position, string _name, string _type): attribute(_position, _name, _type), val(0.0) {}
+    virtual ~numeric ();
+    void set (double x) { val = x; }
+    void print (std::ofstream&) const;
+    void print (std:: ostream&) const;
+};
+
+class nominal: public attribute {
+public:
+    std::vector<string> types;
+    string val;
+    nominal (int _position, string _name, string _type): attribute(_position, _name, _type), val("") {};
+    virtual ~nominal ();
+    virtual string representType (string);
+    void set (string);
+    void print (std::ofstream&) const;
+    void print (std:: ostream&) const;
+};
+
+class stringy: public attribute {
+public:
+    string val;
+    stringy (int _position, string _name, string _type): attribute(_position, _name, _type), val("") {};
+    virtual ~stringy ();
+    void set (string x) { val = representStr(x); }
+    void print (std::ofstream&) const;
+    void print (std:: ostream&) const;
+};
+
+#endif 

wisdm-dataset/arffmagic-master/src/chunk.cpp

@@ -0,0 +1,24 @@
+#include "chunk.h"
+#include "globals.h"
+#include "read.h"
+
+bool validRecord () {
+    return (record.curr != record.prev) && (record.parsed == record.expected);
+}
+
+bool belongsInChunk () {
+    return (chunk.empty()) || (!strcmp(record.toke[0], record.oldToke[0])) || (!strcmp(record.toke[1], record.oldToke[1]));
+}
+
+void addRecord () {
+    for (int i=0; i<NUM_AXIS; i++) {
+        data[i].push_back(atof(record.toke[i+3]));
+    }
+    chunk.resize(chunk.size()+1);   
+}
+void dumpChunk () {
+    for (int i=0; i<NUM_AXIS; i++) {
+        data[i].clear();
+    }
+    chunk.resize(0);
+}

wisdm-dataset/arffmagic-master/src/chunk.h

@@ -0,0 +1,8 @@
+#ifndef CHUNK_H
+#define CHUNK_H
+//what does it mean for records to become a chunk?
+bool validRecord ();
+bool belongsInChunk ();
+void addRecord ();
+void dumpChunk ();
+#endif 

wisdm-dataset/arffmagic-master/src/comparator.h

@@ -0,0 +1,11 @@
+#ifndef COMPARATOR_H
+#define COMPARATOR_H
+
+class comparator {
+public:
+    bool operator () (const std::unique_ptr<attribute>& left, const std::unique_ptr<attribute>& right) const {
+        return left->position < right->position;
+    }
+};
+
+#endif

wisdm-dataset/arffmagic-master/src/except.h

@@ -0,0 +1,41 @@
+#ifndef EXCEPT_H
+#define EXCEPT_H
+#include <stdexcept>
+
+class EpicFail: public std::invalid_argument {
+public:
+    char buf[4096];
+    EpicFail (const char * msg): std::invalid_argument(msg){};
+    virtual const char * specify () {
+        return specify("error", "god knows...");
+    }
+    virtual const char * specify (const char * errorLeft, const char * errorRight) {
+        sprintf(buf, "%s: \"%s\"\n", errorLeft, errorRight);
+        return buf;
+    }
+    virtual const char * specify (const char * errorLeft, const char * errorRight, const char * errorHint) {
+        sprintf(buf, "%s: \"%s\"\n(%s)\n", errorLeft, errorRight, errorHint);
+        return buf;
+    }
+};
+
+class ArgumentFail: public EpicFail {
+public:
+    virtual const char * specify () {
+        sprintf(buf, "%s: %-s\n%7s%-8s: %-s\n%7s%-8s: %-s\n", "USAGE", "arffmagic infile outfile", "", "infile", "raw data (.txt)", "", "outfile", "generated instances (.arff)");
+        return buf;
+    }
+    ArgumentFail(): EpicFail(specify()) {}; 
+};
+
+class OpenFileFail: public EpicFail {
+public:
+    OpenFileFail(const char * file): EpicFail(specify("failed to open", file)) {};
+};
+
+class AttributeTypeFail: public EpicFail {
+public:
+    AttributeTypeFail(const char * type): EpicFail(specify("unknown type", type, "can only magic on numeric, nominal, and string attributes")) {};
+};
+
+#endif

wisdm-dataset/arffmagic-master/src/funcmap.cpp

@@ -0,0 +1,31 @@
+#include "funcmap.h"
+#include "try.h"
+
+void funcmap::hash () {
+    for (auto& x: pairs) { 
+        x.second(x.first); 
+    } 
+}
+
+void funcmap::writeHeader (std::ofstream& ofs) {
+    for (auto& x: pairs) {
+        ofs << x.first->declare() << std::endl;
+    } 
+    ofs << std::endl;
+}
+
+void funcmap::push (int position, string name, string type, void(*calc)(const std::unique_ptr<attribute>&)) throw (AttributeTypeFail) {
+    std::unique_ptr<attribute> curr = nullptr;
+    tryOrDie([this, &curr, &position, &name, &type, &calc]() { 
+        if (type == "numeric") {
+            curr = std::unique_ptr<attribute>(new numeric(position, name, type));
+        } else if (type == "string") {
+            curr = std::unique_ptr<attribute>(new stringy(position, name, type));
+        } else if (type == "nominal") {
+            curr = std::unique_ptr<attribute>(new nominal(position, name, ""));
+        } else {
+            throw AttributeTypeFail(type.c_str());
+        } 
+        pairs.insert(std::make_pair(std::move(curr), calc));
+    });
+}

wisdm-dataset/arffmagic-master/src/funcmap.h

@@ -0,0 +1,28 @@
+#ifndef FUNCMAP_H
+#define FUNCMAP_H
+#include <fstream>
+#include <vector>
+#include <map>
+#include "attribute.h"
+#include "comparator.h"
+#include "except.h"
+
+class funcmap {
+public:
+    template <typename stream>
+    friend stream& operator << (stream& strm, const funcmap * container) {
+        for (auto& x: container->pairs) {
+            strm << x.first;
+            if (x != *(container->pairs.rbegin())) {
+                strm << ",";
+            }
+        } return strm;
+    }
+    void push (int, string, string, void(*)(const std::unique_ptr<attribute>&)) throw (AttributeTypeFail);
+    void hash ();
+    void writeHeader (std::ofstream&);
+private:
+    std::map<const std::unique_ptr<attribute>, void(*)(const std::unique_ptr<attribute>&), comparator> pairs;
+};
+
+#endif

wisdm-dataset/arffmagic-master/src/globals.cpp

@@ -0,0 +1,5 @@
+#include "globals.h"
+
+instancer chunk(WINDOW_SIZE * SAMPLING_RATE);
+liner record(NUM_TOKENS);
+std::vector<double> data[NUM_AXIS];

wisdm-dataset/arffmagic-master/src/globals.h

@@ -0,0 +1,27 @@
+#ifndef GLOBALS_H
+#define GLOBALS_H
+#include "raw.h"
+#include <vector>
+
+const int NUM_AXIS = 3;
+const int WINDOW_SIZE = 10;
+const int SAMPLING_RATE = 20;
+const int NUM_TOKENS = 3 + NUM_AXIS;
+const int AX1 = (int) 'X';
+const int AX2 = (int) 'Y';
+const int AX3 = (int) 'Z';
+const int NUM_BINS = 10;
+const int TOTAL_BINS = NUM_AXIS * NUM_BINS;
+const int NUM_MFCC = 13;
+const int TOTAL_MFCC = NUM_AXIS * NUM_MFCC;
+
+extern int BIN_START;
+extern int XMFCC_START;
+extern int YMFCC_START;
+extern int ZMFCC_START;
+extern int coefIndex;
+extern instancer chunk;
+extern liner record;
+extern std::vector<double> data[];
+
+#endif

wisdm-dataset/arffmagic-master/src/libmfcc.c

@@ -0,0 +1,165 @@
+/*
+ * libmfcc.c - Code implementation for libMFCC
+ * Copyright (c) 2010 Jeremy Sawruk
+ *
+ * This code is released under the MIT License. 
+ * For conditions of distribution and use, see the license in LICENSE
+ */
+
+#include <math.h>
+#include "libmfcc.h"
+
+/* 
+ * Computes the specified (mth) MFCC
+ *
+ * spectralData - array of doubles containing the results of FFT computation. This data is already assumed to be purely real
+ * samplingRate - the rate that the original time-series data was sampled at (i.e 44100)
+ * NumFilters - the number of filters to use in the computation. Recommended value = 48
+ * binSize - the size of the spectralData array, usually a power of 2
+ * m - The mth MFCC coefficient to compute
+ *
+ */
+double GetCoefficient(double* spectralData, unsigned int samplingRate, unsigned int NumFilters, unsigned int binSize, unsigned int m)
+{
+        double result = 0.0f;
+        double outerSum = 0.0f;
+        double innerSum = 0.0f;
+        unsigned int k, l;
+
+        // 0 <= m < L
+        if(m >= NumFilters)
+        {
+                // This represents an error condition - the specified coefficient is greater than or equal to the number of filters. The behavior in this case is undefined.
+                return 0.0f;
+        }
+
+        result = NormalizationFactor(NumFilters, m);
+
+        
+        for(l = 1; l <= NumFilters; l++)
+        {
+                // Compute inner sum
+                innerSum = 0.0f;
+                for(k = 0; k < binSize - 1; k++)
+                {
+                        innerSum += fabs(spectralData[k] * GetFilterParameter(samplingRate, binSize, k, l));
+                }
+
+                if(innerSum > 0.0f)
+                {
+                        innerSum = log(innerSum); // The log of 0 is undefined, so don't use it
+                }
+
+                innerSum = innerSum * cos(((m * PI) / NumFilters) * (l - 0.5f));
+
+                outerSum += innerSum;
+        }
+
+        result *= outerSum;
+
+        return result;
+}
+
+/* 
+ * Computes the Normalization Factor (Equation 6)
+ * Used for internal computation only - not to be called directly
+ */
+double NormalizationFactor(int NumFilters, int m)
+{
+        double normalizationFactor = 0.0f;
+
+        if(m == 0)
+        {
+                normalizationFactor = sqrt(1.0f / NumFilters);
+        }
+        else 
+        {
+                normalizationFactor = sqrt(2.0f / NumFilters);
+        }
+        
+        return normalizationFactor;
+}
+
+/* 
+ * Compute the filter parameter for the specified frequency and filter bands (Eq. 2)
+ * Used for internal computation only - not the be called directly
+ */
+double GetFilterParameter(unsigned int samplingRate, unsigned int binSize, unsigned int frequencyBand, unsigned int filterBand)
+{
+        double filterParameter = 0.0f;
+
+        double boundary = (frequencyBand * samplingRate) / binSize;             // k * Fs / N
+        double prevCenterFrequency = GetCenterFrequency(filterBand - 1);                // fc(l - 1) etc.
+        double thisCenterFrequency = GetCenterFrequency(filterBand);
+        double nextCenterFrequency = GetCenterFrequency(filterBand + 1);
+
+        if(boundary >= 0 && boundary < prevCenterFrequency)
+        {
+                filterParameter = 0.0f;
+        }
+        else if(boundary >= prevCenterFrequency && boundary < thisCenterFrequency)
+        {
+                filterParameter = (boundary - prevCenterFrequency) / (thisCenterFrequency - prevCenterFrequency);
+                filterParameter *= GetMagnitudeFactor(filterBand);
+        }
+        else if(boundary >= thisCenterFrequency && boundary < nextCenterFrequency)
+        {
+                filterParameter = (boundary - nextCenterFrequency) / (thisCenterFrequency - nextCenterFrequency);
+                filterParameter *= GetMagnitudeFactor(filterBand);
+        }
+        else if(boundary >= nextCenterFrequency && boundary < samplingRate)
+        {
+                filterParameter = 0.0f;
+        }
+
+        return filterParameter;
+}
+
+/* 
+ * Compute the band-dependent magnitude factor for the given filter band (Eq. 3)
+ * Used for internal computation only - not the be called directly
+ */
+double GetMagnitudeFactor(unsigned int filterBand)
+{
+        double magnitudeFactor = 0.0f;
+        
+        if(filterBand >= 1 && filterBand <= 14)
+        {
+                magnitudeFactor = 0.015;
+        }
+        else if(filterBand >= 15 && filterBand <= 48)
+        {
+                magnitudeFactor = 2.0f / (GetCenterFrequency(filterBand + 1) - GetCenterFrequency(filterBand -1));
+        }
+
+        return magnitudeFactor;
+}
+
+/*
+ * Compute the center frequency (fc) of the specified filter band (l) (Eq. 4)
+ * This where the mel-frequency scaling occurs. Filters are specified so that their
+ * center frequencies are equally spaced on the mel scale
+ * Used for internal computation only - not the be called directly
+ */
+double GetCenterFrequency(unsigned int filterBand)
+{
+        double centerFrequency = 0.0f;
+        double exponent;
+
+        if(filterBand == 0)
+        {
+                centerFrequency = 0;
+        }
+        else if(filterBand >= 1 && filterBand <= 14)
+        {
+                centerFrequency = (200.0f * filterBand) / 3.0f;
+        }
+        else
+        {
+                exponent = filterBand - 14.0f;
+                centerFrequency = pow(1.0711703, exponent);
+                centerFrequency *= 1073.4;
+        }
+        
+        return centerFrequency;
+}

wisdm-dataset/arffmagic-master/src/libmfcc.h

@@ -0,0 +1,26 @@
+/*
+ * libmfcc.h - Header for libMFCC
+ * Copyright (c) 2010 Jeremy Sawruk
+ *
+ * This code is released under the MIT License. 
+ * For conditions of distribution and use, see the license in LICENSE
+ */
+
+#pragma once
+
+#define PI 3.14159265358979323846264338327
+
+// Returns the specified (mth) MFCC
+double GetCoefficient(double* spectralData, unsigned int samplingRate, unsigned int NumFilters, unsigned int binSize, unsigned int m);
+
+// Compute the normalization factor (For internal computation only - not to be called directly)
+double NormalizationFactor(int NumFilters, int m);
+
+// Compute the filter parameter for the specified frequency and filter bands (For internal computation only - not the be called directly)
+double GetFilterParameter(unsigned int samplingRate, unsigned int binSize, unsigned int frequencyBand, unsigned int filterBand);
+
+// Compute the band-dependent magnitude factor for the given filter band (For internal computation only - not the be called directly)
+double GetMagnitudeFactor(unsigned int filterBand);
+
+// Compute the center frequency (fc) of the specified filter band (l) (For internal computation only - not the be called directly)
+double GetCenterFrequency(unsigned int filterBand);

wisdm-dataset/arffmagic-master/src/main.cpp

@@ -0,0 +1,19 @@
+#include "try.h"
+#include "except.h"
+#include "read.h"
+#include "write.h"
+#include "arff.h"
+
+void validateArgs (int argc) throw (ArgumentFail) {
+    if (argc != 3) {
+        throw ArgumentFail();
+    }
+}
+
+int main (int argc, char ** argv) {
+    tryOrDie([&]() {
+        validateArgs(argc); 
+        arff magic(argv, initribute, rawdog);
+    });
+}
+

wisdm-dataset/arffmagic-master/src/raw.cpp

@@ -0,0 +1,38 @@
+#include "raw.h"
+
+instancer::instancer (int x): valid(0), invalid(0), MAX(x), MIN(0.9*x), count(0) {};
+
+liner::liner (int x): expected(x), parsed(0), toke(NULL), oldToke(NULL), prev(""), curr("") {
+    size_t size = sizeof(char **) * (expected + 1);
+    toke = (char **) malloc(size);
+    oldToke = (char **) malloc(size);
+    memset(toke, '\0', size);
+    memset(oldToke, '\0', size);
+}
+
+void liner::update () {
+    prev = curr;
+    for (int i=0; i<expected; i++) {
+        if (toke[i]) {
+            free(oldToke[i]);
+            oldToke[i] = toke[i];
+        }
+    }
+}
+
+void liner::tokenize () {
+    parsed = 0;
+    const char * c_str = curr.c_str(); 
+    char * dup = strdup(c_str); 
+    char * token = strtok(dup, ",;:");
+    while (token && parsed<expected) {
+        toke[parsed] = strdup(token);
+        parsed++;
+        token = strtok(NULL, ",;:");
+    } free(dup);
+}
+
+liner::~liner () {
+    free(toke);
+    free(oldToke);
+}

wisdm-dataset/arffmagic-master/src/raw.h

@@ -0,0 +1,36 @@
+#ifndef RAW_H
+#define RAW_H
+#include <cstdlib>
+#include <string>
+
+class instancer {
+public:
+    int valid;
+    int invalid;
+    instancer (int);
+    void resize (unsigned int size) { count = size; };
+    int size () { return count; };
+    bool empty () const { return count == 0; }
+    bool min () const { return count >= MIN; };
+    bool full () const { return count == MAX; };
+private:
+    const int MAX;
+    const int MIN;
+    int count;
+};
+
+class liner {
+public:
+    const int expected;
+    int parsed;
+    char ** toke;
+    char ** oldToke;
+    std::string prev;
+    std::string curr;
+    void tokenize ();
+    void update ();
+    liner  (int);
+    ~liner ();
+};
+
+#endif

wisdm-dataset/arffmagic-master/src/read.cpp

@@ -0,0 +1,33 @@
+#include "read.h"
+#include "globals.h"
+#include "chunk.h"
+#include "write.h"
+
+void getRecord (arff& barf) {
+    getline(barf.rawStream, record.curr);
+    record.tokenize();
+}
+
+void rawdog (arff& barf) {
+    while (barf.rawStream.good()) {
+        bool instance = false; bool discard = false;
+        if (validRecord()) {
+            if (belongsInChunk()) {
+                if (!chunk.full()) {
+                    addRecord();
+                } else {
+                    instance = true;
+                }
+            } else if (!chunk.min()) {
+                discard = true;
+            } else {
+                instance = true;
+            }
+        } if (instance) {
+            writeInstance(barf);
+        } else if (!discard) {
+            record.update();
+            getRecord(barf);
+        }
+    }
+}

wisdm-dataset/arffmagic-master/src/read.h

@@ -0,0 +1,7 @@
+#ifndef READ_H
+#define READ_H
+#include "arff.h"
+//process of reading through the raw data file
+void getRecord (arff&);
+void rawdog (arff&);
+#endif 

wisdm-dataset/arffmagic-master/src/try.h

@@ -0,0 +1,14 @@
+#ifndef TRY_H
+#define TRY_H
+#include "except.h"
+#include <iostream>
+template <typename x>
+void tryOrDie (x func) {
+    try {
+        func();
+    } catch (const EpicFail& wtf) {
+        std::cerr << wtf.what();
+        exit(1);
+    }
+}
+#endif

wisdm-dataset/arffmagic-master/src/write.cpp

@@ -0,0 +1,257 @@
+#include "write.h"
+#include "read.h"
+#include "chunk.h"
+#include "globals.h"
+#include "aquila/aquila.h"
+#include "libmfcc.h"
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_statistics.h>
+#include <cmath>
+
+int binOffset = 0; 
+int mfccOffset = 0;
+
+double avg [NUM_AXIS];
+double sdev[NUM_AXIS];
+int bins[NUM_AXIS][NUM_BINS];
+vector<double> coefs[NUM_AXIS];
+
+void initribute (arff& barf) {
+    barf.setRelation("person_activities_labeled");
+
+    /*  ADDING ATTRIBUTES TO ARFFMAGIC!
+    for each attribute desired, make a call to the following arff member function
+        add(<int>, <void(*)(const std::unique_ptr<attribute>&)>, <string>, <string>)
+    with corresponding parameters 
+        (1) position in instance (AKA position in arff header/attribute declaration)
+        (2) function (that you need to define) to set the attribute's value
+        (3) name (used for attribute declaration)
+        (4--optional) type (defaults to "numeric", alternatively specify "string" or "nominal") 
+    Only attributes added in this function will appear in the generated arff! */
+
+    int n = 1;
+    barf.add(n++, activity, "ACTIVITY", "nominal");
+
+    binOffset = n;
+    for (int ax = AX1; ax < (NUM_AXIS + AX1); ax++) {
+        int start = NUM_BINS * (ax-AX1);
+        string str = "";
+        str += (char)ax;
+        for (n = start; n < (start + NUM_BINS); n++) {
+            barf.add(n+binOffset, bin, str+(std::to_string(n % NUM_BINS)));
+        } n += (TOTAL_BINS - n) + (ax - AX1) + binOffset;
+        barf.add(n, average, str + "AVG");
+        barf.add(n+=NUM_AXIS, peak, str + "PEAK");
+        barf.add(n+=NUM_AXIS, absoluteDev, str + "ABSOLDEV");
+        barf.add(n+=NUM_AXIS, standardDev, str + "STANDDEV");
+        barf.add(n+=NUM_AXIS, variance, str + "VAR");
+    }
+
+    mfccOffset = n+1;
+    for (int ax = AX1; ax < (NUM_AXIS + AX1); ax++) {
+        int start = NUM_MFCC * (ax-AX1);
+        string str = "";
+        str += (char)ax;
+        str += "MFCC";
+        for (n = start; n < (start + NUM_MFCC); n++) {
+            barf.add(n+mfccOffset, mfcc, str+(std::to_string(n % NUM_MFCC)));
+        } n += (TOTAL_MFCC - n) + (ax - AX1) + mfccOffset;
+    }
+
+    barf.add(++n, cosineSimilarity, "XYCOS");
+    barf.add(++n, cosineSimilarity, "XZCOS");
+    barf.add(++n, cosineSimilarity, "YZCOS");
+    barf.add(++n, correlation, "XYCOR");
+    barf.add(++n, correlation, "XZCOR");
+    barf.add(++n, correlation, "YZCOR");
+    barf.add(++n, resultant, "RESULTANT");
+    barf.add(++n, userID, "class", "nominal");
+}
+
+int getAxis (const std::unique_ptr<attribute>& attr, int nameChar) {
+    int axis;
+    switch (attr->name[nameChar]) {
+        case 'X': axis = 0; break;
+        case 'Y': axis = 1; break;
+        case 'Z': axis = 2; break;
+    } 
+    return axis;
+}
+
+void activity (const std::unique_ptr<attribute>& attr) {
+    attr->set(record.toke[1]);
+}
+
+void bin (const std::unique_ptr<attribute>& attr) {
+    int ax = getAxis(attr, 0);
+    attr->set((bins[ax][getBindex(attr)])/((double)chunk.size()));
+}
+
+int getBindex (const std::unique_ptr<attribute>& attr) {
+    int bindex = ((attr->position)-binOffset)%NUM_BINS;
+    return bindex;
+}
+
+void average (const std::unique_ptr<attribute>& attr) {
+    int ax = getAxis(attr, 0);
+    attr->set(avg[ax]);
+}
+
+void peak (const std::unique_ptr<attribute>& attr) {
+    int sum = 0;
+    vector<int> dists = getDists(getPeaks(attr));
+    for (auto dist: dists) {
+        sum += dist;
+    } 
+    attr->set(((double)sum/dists.size())*NUM_BINS);
+}
+
+vector<int> getPeaks (const std::unique_ptr<attribute>& attr) {
+    int ax = getAxis(attr, 0);
+    vector<int> peaks;
+    if (data[ax][0] > data[ax][1]) {
+        peaks.push_back(0);
+    } for (int i=1; i<(chunk.size()-2); i++) {
+        if ((data[ax][i] > data[ax][i-1]) && data[ax][i] > data[ax][i+1]) {
+            peaks.push_back(i);
+        }
+    } 
+    if (data[ax][chunk.size()-1] > data[ax][chunk.size()-2]) {
+        peaks.push_back(chunk.size()-1);
+    } 
+    return peaks;
+}
+
+vector<int> getDists (vector<int> peaks) {
+    vector<int> dists;
+    for (unsigned long i=0; i<(peaks.size()-2); i++) {
+        dists.push_back(peaks[i+1] - peaks[i]);
+    } 
+    return dists;
+}
+
+void absoluteDev (const std::unique_ptr<attribute>& attr) {
+    double dev = 0.0;
+    int ax = getAxis(attr, 0);
+    for (auto var: data[ax]) {
+        dev += std::abs(var-(avg[ax]));
+    } 
+    attr->set(dev/(double)chunk.size());
+}
+
+void standardDev (const std::unique_ptr<attribute>& attr) {
+    int ax = getAxis(attr, 0);
+    attr->set(sdev[ax]);
+}
+
+void variance (const std::unique_ptr<attribute>& attr) {
+    int ax = getAxis(attr, 0);
+    attr->set(sqrt(sdev[ax]));
+}
+
+int getCoefIndex (const std::unique_ptr<attribute>& attr) {
+    int coefIndex = ((attr->position)-mfccOffset)%NUM_MFCC;
+    return coefIndex;
+}
+
+void mfcc (const std::unique_ptr<attribute>& attr) {
+    int ax = getAxis(attr, 0);
+    attr->set(coefs[ax][getCoefIndex(attr)]);   
+}
+
+void cosineSimilarity (const std::unique_ptr<attribute>& attr) {
+    vector<double> * left = &data[getAxis(attr, 0)];
+    vector<double> * right = &data[getAxis(attr, 1)];
+    double top = 0.0;
+    double bottomLeft = 0.0;
+    double bottomRight = 0.0;
+    for (size_t i=0; i<(*left).size(); i++) {
+        top += (((*left)[i])*((*right)[i]));
+        bottomLeft  += pow((* left)[i], 2);
+        bottomRight += pow((*right)[i], 2);
+    } 
+    attr->set(top/((sqrt(bottomLeft))*(sqrt(bottomRight))));
+}
+
+void correlation (const std::unique_ptr<attribute>& attr) {
+    vector<double> * left = &data[getAxis(attr, 0)];
+    vector<double> * right = &data[getAxis(attr, 1)];
+    gsl_vector_const_view gslLeft = gsl_vector_const_view_array((*left).data(), (*left).size());
+    gsl_vector_const_view gslRight = gsl_vector_const_view_array((*right).data(), (*right).size());
+    attr->set(gsl_stats_correlation(gslLeft.vector.data, 1, gslRight.vector.data, 1, (*left).size()));
+}
+
+// template <typename x>
+// void iterateChunk (x func) {
+//     for (int j=0; j<chunk.size(); j++) {
+//         func(j);
+//     }
+// }
+
+void resultant (const std::unique_ptr<attribute>& attr) {
+    double sum = 0.0;
+    for (int i=0; i<chunk.size(); i++) {
+        double squared = 0.0;
+        for (int j=0; j<NUM_AXIS; j++) {
+            squared += pow(data[j][i], 2);
+        }
+        sum += sqrt(squared);
+    }
+    attr->set(sum/((double)chunk.size()));
+}
+
+
+void userID (const std::unique_ptr<attribute>& attr) {
+    attr->set(record.toke[0]);
+}
+
+int binDrop (double var) {
+    int bindex = 0;
+    var = (double) var/2.5;
+    if (var >= -1 && var <= 7) {
+        bindex = (floor(var))+2; 
+    } else if (var > 7) {
+        bindex = 9;
+    } 
+    return bindex;
+}
+
+vector<double> getFFT (vector<double> data) {
+    size_t before = data.size();
+    while ((data.size() & (data.size()-1)) != 0) {
+        data.push_back(0.0);
+    }
+    Aquila::SignalSource source(data, SAMPLING_RATE);
+    Aquila::AquilaFft fft(source.getSamplesCount());
+    auto spectrum = fft.fft(source.toArray());
+    std::vector<double> realFFT;
+    for (auto complex: spectrum) {
+        realFFT.push_back(std::abs(complex));
+    }
+    chunk.resize(before);
+    return realFFT;
+}
+
+void writeInstance (arff& barf) {
+    for (int i=0; i<NUM_AXIS; i++) {
+        avg[i] = sdev[i] = 0.0;
+        coefs[i].clear();
+        memset(bins[i], 0, sizeof(int) * NUM_BINS);
+        for (auto val: data[i]) {
+            bins[i][binDrop(val)]++;
+            avg[i] += val;
+        }
+        avg[i] /= chunk.size();
+        for (auto val: data[i]) {
+            sdev[i] += pow((val-avg[i]), 2);
+        }
+        sdev[i] = (sqrt(sdev[i]))/((double)chunk.size());
+        vector<double> FFT = getFFT(data[i]);
+        for (int j=0; j<NUM_MFCC; j++) {
+            coefs[i].push_back(GetCoefficient(FFT.data(), SAMPLING_RATE, 48, FFT.size(), j));
+        }
+    }
+    barf.compute();
+    dumpChunk();
+    chunk.valid++;
+}

wisdm-dataset/arffmagic-master/src/write.h

@@ -0,0 +1,31 @@
+#ifndef WRITE_H
+#define WRITE_H
+#include "attribute.h"
+#include "arff.h"
+#include <vector>
+using std::vector;
+// process writing to the arff file
+
+void initribute (arff&);
+//axis * 
+int getAxis (const std::unique_ptr<attribute>&, int);
+void activity (const std::unique_ptr<attribute>&);
+void bin (const std::unique_ptr<attribute>&);
+int getBindex (const std::unique_ptr<attribute>&);
+void average  (const std::unique_ptr<attribute>&);
+void peak (const std::unique_ptr<attribute>&);
+vector<int> getPeaks (const std::unique_ptr<attribute>&);
+vector<int> getDists (vector<int>);
+void absoluteDev (const std::unique_ptr<attribute>&);
+void standardDev (const std::unique_ptr<attribute>&);
+void variance (const std::unique_ptr<attribute>&);
+void mfcc (const std::unique_ptr<attribute>&);
+void cosineSimilarity (const std::unique_ptr<attribute>&);
+void correlation (const std::unique_ptr<attribute>&);
+void resultant (const std::unique_ptr<attribute>&);
+double square (double);
+void userID (const std::unique_ptr<attribute>&);
+void writeInstance (arff&);
+
+
+#endif