midas-edge 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e4c7b4cac2e7a9dac3a6085b40d79a48b9f14dad32834e0d267f7bb667d86b9
-  data.tar.gz: abd0836d284e7a9c34c7733f2f195e38faca2fb1ac6ab01687c3790bc96d3cfa
+  metadata.gz: b0d27786d0b99888ae441ad574d70f3686d206395dacef5273e473e90f35ec78
+  data.tar.gz: 8383b227b506effe504636f8284e67f304732c463daa1e5251236c4ddf5b3d4c
 SHA512:
-  metadata.gz: 48c92dbdbff039a514ca99207a88276fada4a1391497a1fd4595176f90bec0ac46f0fc89126d36c7ccfc3a1afe212aa11f2142fb7d3d836734f64ab912a88ffb
-  data.tar.gz: 9a2a140ed5d5a120969ee5fc0a599cccc6d590755c9eddf949c2e0a5897aaf39b6f8fe8137c9dde3fd418c78f04cdd8801d1353ca61009d4fbae5a610ad2edc5
+  metadata.gz: daa76e1ec74019adedb1ac4d187a303e549735024ac5fa1f410805b93cf2f8d8a2902ad94dcb7057f35c7a968bb595a6760b72e245a45a1dfbd0e33914c81702
+  data.tar.gz: f49958b7c705a72e1c8af80ac982dc58c272db360efef9632971b00a2f38ca58890728a33b1fcf6ba53bb89fe9f13227d49a34499c492c0a0b7fcd11b4ce3412

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.1 (2020-06-17)
+
+- Fixed installation (missing header files)
+
 ## 0.2.0 (2020-06-17)
 
 - Updated MIDAS to 1.0.0

data/lib/midas/version.rb

@@ -1,3 +1,3 @@
 module Midas
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/vendor/MIDAS/src/EdgeHash.hpp

@@ -0,0 +1,104 @@
+// -----------------------------------------------------------------------------
+// Copyright 2020 Rui Liu (liurui39660) and Siddharth Bhatia (bhatiasiddharth)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// -----------------------------------------------------------------------------
+
+#pragma once
+
+#include <algorithm>
+
+namespace MIDAS {
+struct EdgeHash {
+	// Fields
+	// --------------------------------------------------------------------------------
+
+	const int r, c, m = 104729; // Yes, a magic number, I just pick a random prime
+	const int lenData;
+	int* const param1;
+	int* const param2;
+	float* const data;
+	constexpr static float infinity = std::numeric_limits<float>::infinity();
+
+	// Methods
+	// --------------------------------------------------------------------------------
+
+	EdgeHash() = delete;
+	EdgeHash& operator=(const EdgeHash& b) = delete;
+
+	EdgeHash(int numRow, int numColumn):
+		r(numRow),
+		c(numColumn),
+		lenData(r * c),
+		param1(new int[r]),
+		param2(new int[r]),
+		data(new float[lenData]) {
+		for (int i = 0; i < r; i++) {
+			param1[i] = rand() + 1; // ×0 is not a good idea, see Hash()
+			param2[i] = rand();
+		}
+		std::fill(data, data + lenData, 0);
+	}
+
+	EdgeHash(const EdgeHash& b):
+		r(b.r),
+		c(b.c),
+		lenData(b.lenData),
+		param1(new int[r]),
+		param2(new int[r]),
+		data(new float[lenData]) {
+		std::copy(b.param1, b.param1 + r, param1);
+		std::copy(b.param2, b.param2 + r, param2);
+		std::copy(b.data, b.data + lenData, data);
+	}
+
+	~EdgeHash() {
+		delete[] param1;
+		delete[] param2;
+		delete[] data;
+	}
+
+	void ClearAll(float with = 0) const {
+		std::fill(data, data + lenData, with);
+	}
+
+	void MultiplyAll(float by) const {
+		std::for_each(data, data + lenData, [&](float& a) { a *= by; }); // Magic of vectorization
+	}
+
+	void Hash(int a, int b, int* indexOut) const {
+		for (int i = 0; i < r; i++) {
+			indexOut[i] = ((a + m * b) * param1[i] + param2[i]) % c;
+			indexOut[i] += i * c + (indexOut[i] < 0 ? c : 0);
+		}
+	}
+
+	float operator()(const int* index) const {
+		float least = infinity;
+		for (int i = 0; i < r; i++)
+			least = std::min(least, data[index[i]]);
+		return least;
+	}
+
+	float Assign(const int* index, float to) const {
+		for (int i = 0; i < r; i++)
+			data[index[i]] = to;
+		return to;
+	}
+
+	void Add(const int* index, float by = 1) const {
+		for (int i = 0; i < r; i++)
+			data[index[i]] += by;
+	}
+};
+}

data/vendor/MIDAS/src/FilteringCore.hpp

@@ -0,0 +1,95 @@
+// -----------------------------------------------------------------------------
+// Copyright 2020 Rui Liu (liurui39660) and Siddharth Bhatia (bhatiasiddharth)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// -----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+#include <algorithm>
+
+#include "EdgeHash.hpp"
+#include "NodeHash.hpp"
+
+namespace MIDAS {
+struct FilteringCore {
+	const float threshold;
+	int timestampCurrent = 1;
+	const float factor;
+	int* const indexEdge; // Pre-compute the index to-be-modified, thanks to the same structure of CMSs
+	int* const indexSource;
+	int* const indexDestination;
+	EdgeHash numCurrentEdge, numTotalEdge, scoreEdge;
+	NodeHash numCurrentSource, numTotalSource, scoreSource;
+	NodeHash numCurrentDestination, numTotalDestination, scoreDestination;
+
+	FilteringCore(int numRow, int numColumn, float threshold, float factor = 0.5):
+		threshold(threshold),
+		factor(factor),
+		indexEdge(new int[numRow]),
+		indexSource(new int[numRow]),
+		indexDestination(new int[numRow]),
+		numCurrentEdge(numRow, numColumn),
+		numTotalEdge(numCurrentEdge),
+		scoreEdge(numCurrentEdge),
+		numCurrentSource(numRow, numColumn),
+		numTotalSource(numCurrentSource),
+		scoreSource(numCurrentSource),
+		numCurrentDestination(numRow, numColumn),
+		numTotalDestination(numCurrentDestination),
+		scoreDestination(numCurrentDestination) { }
+
+	virtual ~FilteringCore() {
+		delete[] indexEdge;
+		delete[] indexSource;
+		delete[] indexDestination;
+	}
+
+	static float ComputeScore(float a, float s, float t) {
+		return s == 0 ? 0 : pow(a + s - a * t, 2) / (s * (t - 1)); // If t == 1, then s == 0, so no need to check twice
+	}
+
+	float operator()(int source, int destination, int timestamp) {
+		if (timestamp > timestampCurrent) {
+			for (int i = 0; i < numCurrentEdge.lenData; i++)
+				numTotalEdge.data[i] += scoreEdge.data[i] < threshold ?
+					numCurrentEdge.data[i] : timestampCurrent - 1 ?
+						numTotalEdge.data[i] / (timestampCurrent - 1) : 0;
+			for (int i = 0; i < numCurrentSource.lenData; i++)
+				numTotalSource.data[i] += scoreSource.data[i] < threshold ?
+					numCurrentSource.data[i] : timestampCurrent - 1 ?
+						numTotalSource.data[i] / (timestampCurrent - 1) : 0;
+			for (int i = 0; i < numCurrentDestination.lenData; i++)
+				numTotalDestination.data[i] += scoreDestination.data[i] < threshold ?
+					numCurrentDestination.data[i] : timestampCurrent - 1 ?
+						numTotalDestination.data[i] / (timestampCurrent - 1) : 0;
+			numCurrentEdge.MultiplyAll(factor);
+			numCurrentSource.MultiplyAll(factor);
+			numCurrentDestination.MultiplyAll(factor);
+			timestampCurrent = timestamp;
+		}
+		numCurrentEdge.Hash(source, destination, indexEdge);
+		numCurrentEdge.Add(indexEdge);
+		numCurrentSource.Hash(source, indexSource);
+		numCurrentSource.Add(indexSource);
+		numCurrentDestination.Hash(destination, indexDestination);
+		numCurrentDestination.Add(indexDestination);
+		return std::max({
+			scoreEdge.Assign(indexEdge, ComputeScore(numCurrentEdge(indexEdge), numTotalEdge(indexEdge), timestamp)),
+			scoreSource.Assign(indexSource, ComputeScore(numCurrentSource(indexSource), numTotalSource(indexSource), timestamp)),
+			scoreDestination.Assign(indexDestination, ComputeScore(numCurrentDestination(indexDestination), numTotalDestination(indexDestination), timestamp)),
+		});
+	}
+};
+}

data/vendor/MIDAS/src/NodeHash.hpp

@@ -0,0 +1,104 @@
+// -----------------------------------------------------------------------------
+// Copyright 2020 Rui Liu (liurui39660) and Siddharth Bhatia (bhatiasiddharth)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// -----------------------------------------------------------------------------
+
+#pragma once
+
+#include <algorithm>
+
+namespace MIDAS {
+struct NodeHash {
+	// Fields
+	// --------------------------------------------------------------------------------
+
+	const int r, c;
+	const int lenData;
+	int* const param1;
+	int* const param2;
+	float* const data;
+	constexpr static float infinity = std::numeric_limits<float>::infinity();
+
+	// Methods
+	// --------------------------------------------------------------------------------
+
+	NodeHash() = delete;
+	NodeHash& operator=(const NodeHash& b) = delete;
+
+	NodeHash(int numRow, int numColumn):
+		r(numRow),
+		c(numColumn),
+		lenData(r * c),
+		param1(new int[r]),
+		param2(new int[r]),
+		data(new float[lenData]) {
+		for (int i = 0; i < r; i++) {
+			param1[i] = rand() + 1; // ×0 is not a good idea, see Hash()
+			param2[i] = rand();
+		}
+		std::fill(data, data + lenData, 0);
+	}
+
+	NodeHash(const NodeHash& b):
+		r(b.r),
+		c(b.c),
+		lenData(b.lenData),
+		param1(new int[r]),
+		param2(new int[r]),
+		data(new float[lenData]) {
+		std::copy(b.param1, b.param1 + r, param1);
+		std::copy(b.param2, b.param2 + r, param2);
+		std::copy(b.data, b.data + lenData, data);
+	}
+
+	~NodeHash() {
+		delete[] param1;
+		delete[] param2;
+		delete[] data;
+	}
+
+	void ClearAll(float with = 0) const {
+		std::fill(data, data + lenData, with);
+	}
+
+	void MultiplyAll(float by) const {
+		std::for_each(data, data + lenData, [&](float& a) { a *= by; }); // Magic of vectorization
+	}
+
+	void Hash(int a, int* indexOut) const {
+		for (int i = 0; i < r; i++) {
+			indexOut[i] = (a * param1[i] + param2[i]) % c;
+			indexOut[i] += i * c + (indexOut[i] < 0 ? c : 0);
+		}
+	}
+
+	float operator()(const int* index) const {
+		float least = infinity;
+		for (int i = 0; i < r; i++)
+			least = std::min(least, data[index[i]]);
+		return least;
+	}
+
+	float Assign(const int* index, float to) const {
+		for (int i = 0; i < r; i++)
+			data[index[i]] = to;
+		return to;
+	}
+
+	void Add(const int* index, float by = 1) const {
+		for (int i = 0; i < r; i++)
+			data[index[i]] += by;
+	}
+};
+}

data/vendor/MIDAS/src/NormalCore.hpp

@@ -0,0 +1,53 @@
+// -----------------------------------------------------------------------------
+// Copyright 2020 Rui Liu (liurui39660) and Siddharth Bhatia (bhatiasiddharth)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// -----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+#include "EdgeHash.hpp"
+
+namespace MIDAS {
+struct NormalCore {
+	int timestampCurrent = 1;
+	int* const index; // Pre-compute the index to-be-modified, thanks to the same structure of CMSs
+	EdgeHash numCurrent, numTotal;
+
+	NormalCore(int numRow, int numColumn):
+		index(new int[numRow]),
+		numCurrent(numRow, numColumn),
+		numTotal(numCurrent) { }
+
+	virtual ~NormalCore() {
+		delete[] index;
+	}
+
+	static float ComputeScore(float a, float s, float t) {
+		return s == 0 || t - 1 == 0 ? 0 : pow((a - s / t) * t, 2) / (s * (t - 1));
+	}
+
+	float operator()(int source, int destination, int timestamp) {
+		if (timestamp > timestampCurrent) {
+			numCurrent.ClearAll();
+			timestampCurrent = timestamp;
+		}
+		numCurrent.Hash(source, destination, index);
+		numCurrent.Add(index);
+		numTotal.Add(index);
+		return ComputeScore(numCurrent(index), numTotal(index), timestamp);
+	}
+};
+}

data/vendor/MIDAS/src/RelationalCore.hpp

@@ -0,0 +1,81 @@
+// -----------------------------------------------------------------------------
+// Copyright 2020 Rui Liu (liurui39660) and Siddharth Bhatia (bhatiasiddharth)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// -----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+#include <algorithm>
+
+#include "EdgeHash.hpp"
+#include "NodeHash.hpp"
+
+namespace MIDAS {
+struct RelationalCore {
+	int timestampCurrent = 1;
+	const float factor;
+	int* const indexEdge; // Pre-compute the index to-be-modified, thanks to the same structure of CMSs
+	int* const indexSource;
+	int* const indexDestination;
+	EdgeHash numCurrentEdge, numTotalEdge;
+	NodeHash numCurrentSource, numTotalSource;
+	NodeHash numCurrentDestination, numTotalDestination;
+
+	RelationalCore(int numRow, int numColumn, float factor = 0.5):
+		factor(factor),
+		indexEdge(new int[numRow]),
+		indexSource(new int[numRow]),
+		indexDestination(new int[numRow]),
+		numCurrentEdge(numRow, numColumn),
+		numTotalEdge(numCurrentEdge),
+		numCurrentSource(numRow, numColumn),
+		numTotalSource(numCurrentSource),
+		numCurrentDestination(numRow, numColumn),
+		numTotalDestination(numCurrentDestination) { }
+
+	virtual ~RelationalCore() {
+		delete[] indexEdge;
+		delete[] indexSource;
+		delete[] indexDestination;
+	}
+
+	static float ComputeScore(float a, float s, float t) {
+		return s == 0 || t - 1 == 0 ? 0 : pow((a - s / t) * t, 2) / (s * (t - 1));
+	}
+
+	float operator()(int source, int destination, int timestamp) {
+		if (timestamp > timestampCurrent) {
+			numCurrentEdge.MultiplyAll(factor);
+			numCurrentSource.MultiplyAll(factor);
+			numCurrentDestination.MultiplyAll(factor);
+			timestampCurrent = timestamp;
+		}
+		numCurrentEdge.Hash(source, destination, indexEdge);
+		numCurrentEdge.Add(indexEdge);
+		numTotalEdge.Add(indexEdge);
+		numCurrentSource.Hash(source, indexSource);
+		numCurrentSource.Add(indexSource);
+		numTotalSource.Add(indexSource);
+		numCurrentDestination.Hash(destination, indexDestination);
+		numCurrentDestination.Add(indexDestination);
+		numTotalDestination.Add(indexDestination);
+		return std::max({
+			ComputeScore(numCurrentEdge(indexEdge), numTotalEdge(indexEdge), timestamp),
+			ComputeScore(numCurrentSource(indexSource), numTotalSource(indexSource), timestamp),
+			ComputeScore(numCurrentDestination(indexDestination), numTotalDestination(indexDestination), timestamp),
+		});
+	}
+};
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: midas-edge
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Andrew Kane
@@ -112,6 +112,11 @@ files:
 - lib/midas/version.rb
 - vendor/MIDAS/LICENSE
 - vendor/MIDAS/README.md
+- vendor/MIDAS/src/EdgeHash.hpp
+- vendor/MIDAS/src/FilteringCore.hpp
+- vendor/MIDAS/src/NodeHash.hpp
+- vendor/MIDAS/src/NormalCore.hpp
+- vendor/MIDAS/src/RelationalCore.hpp
 homepage: https://github.com/ankane/midas
 licenses:
 - MIT