Tree Border Array - quadratic time solution

alib2algo/src/tree/properties/BorderArray.cpp

+/*
+ * BorderArray.cpp
+ *
+ *  Created on: 4. 10. 2019
+ *      Author: Tomas Pecka, Jan Travnicek
+ */
+
+#include "BorderArray.h"
+#include <registration/AlgoRegistration.hpp>
+
+namespace {
+
+auto BorderArrayPrefixRankedBarNonlinearPattern = registration::AbstractRegister < tree::properties::BorderArray, ext::vector < size_t >, const tree::PrefixRankedBarNonlinearPattern < > & > ( tree::properties::BorderArray::construct );
+auto BorderArrayPrefixRankedBarPattern          = registration::AbstractRegister < tree::properties::BorderArray, ext::vector < size_t >, const tree::PrefixRankedBarPattern < > & >          ( tree::properties::BorderArray::construct );
+auto BorderArrayPrefixRankedNonlinearPattern    = registration::AbstractRegister < tree::properties::BorderArray, ext::vector < size_t >, const tree::PrefixRankedNonlinearPattern < > & >    ( tree::properties::BorderArray::construct );
+auto BorderArrayPrefixRankedPattern             = registration::AbstractRegister < tree::properties::BorderArray, ext::vector < size_t >, const tree::PrefixRankedPattern < > & >             ( tree::properties::BorderArray::construct );
+
+} /* namespace */

alib2algo/src/tree/properties/BorderArray.h

+/*
+ * BorderArray.cpp
+ *
+ *  Created on: 4. 10. 2019
+ *      Author: Tomas Pecka, Jan Travnicek
+ */
+
+#ifndef _ARBOLOGY_BORDER_ARRAY_H_
+#define _ARBOLOGY_BORDER_ARRAY_H_
+
+#include <cstdlib>
+
+#include <alib/vector>
+
+#include <global/GlobalData.h>
+
+#include "SubtreeJumpTable.h"
+
+#include <tree/ranked/PrefixRankedBarNonlinearPattern.h>
+#include <tree/ranked/PrefixRankedBarPattern.h>
+#include <tree/ranked/PrefixRankedNonlinearPattern.h>
+#include <tree/ranked/PrefixRankedPattern.h>
+
+namespace tree::properties {
+
+class BorderArray {
+
+public:
+	template < class PrefixRankedPatternType >
+	static ext::vector < size_t > construct ( const PrefixRankedPatternType & pattern );
+};
+
+template < class PrefixRankedPatternType >
+ext::vector < size_t > BorderArray::construct ( const PrefixRankedPatternType & pattern ) {
+	ext::vector < int > subtreeJumpTable = SubtreeJumpTable::compute ( pattern );
+	ext::vector < size_t > res ( pattern.getContent ( ).size ( ) + 1, 0 );
+	ext::vector < unsigned > mins ( pattern.getContent ( ).size ( ) + 1 );
+	for ( unsigned i = 0; i <= pattern.getContent ( ) .size ( ); i++ )
+		mins [ i ] = i + 1;
+	res [ 0 ] = -1;
+
+	for ( unsigned ofs = 1; ofs < pattern.getContent ( ).size ( ); ofs++ ) {
+
+		unsigned i = 0;   // index do patternu
+		unsigned j = ofs; // index do factoru
+
+		while ( 1 ) {
+			if ( i >= pattern.getContent ( ).size ( ) ) {
+				while ( j < pattern.getContent ( ).size ( ) ) {
+					mins [ j ] = std::min ( mins [ j ], ofs );
+					j++;
+				}
+				break;
+			} else if ( j >= pattern.getContent ( ).size ( ) ) {
+				break;
+			} else if ( pattern.getContent ( )[ i ] == pattern.getContent ( )[ j ] ) {
+				mins [ j ] = std::min ( mins [ j ], ofs );;
+				i++;
+				j++;
+			} else if ( pattern.getContent ( )[ i ] == pattern.getSubtreeWildcard ( ) || pattern.getContent ( )[ j ] == pattern.getSubtreeWildcard ( ) ) {
+				for ( int k = ( int ) j; k < subtreeJumpTable [ j ] ; k++ )
+					mins [ k ] = std::min ( mins [ k ], ofs );;
+
+				i = subtreeJumpTable[ i ];
+				j = subtreeJumpTable[ j ];
+			} else {
+				break;
+			}
+		}
+	}
+
+	// std::cout << mins << std::endl;
+
+	for ( size_t i = 1; i <= pattern.getContent ( ).size ( ); i++ ) {
+		res [ i ] = i - mins [ i - 1 ];
+	}
+
+	return res;
+}
+
+} /* namespace tree::properties */
+
+#endif /* _ARBOLOGY_BORDER_ARRAY_H_ */

alib2integrationtest/test-src/tests/borderArrayTest.cpp

+#include <catch2/catch.hpp>
+#include "testing/TimeoutAqlTest.hpp"
+
+#include <tree/properties/BorderArrayNaive.h>
+#include <tree/properties/BorderArray.h>
+
+const size_t PATTERN_SIZE = 50;
+const size_t PATTERN_HEIGHT = 7;
+
+const size_t ALPHABET_SIZE = 3;
+const size_t RANDOM_ITERATIONS = 100;
+
+std::string gen ( const std::string & cast, const std::string & var ) {
+	std::ostringstream oss;
+
+	oss << "execute ( " << cast << " ) tree::generate::RandomRankedPatternFactory ";
+	oss << "(int) " << PATTERN_HEIGHT << " ";
+	oss << "(int) " << PATTERN_SIZE   << " ";
+	oss << "(int) " << ALPHABET_SIZE  << " ";
+	oss << "(bool) false ";
+	oss << "(int) 5"; // rank
+	oss << " > $" << var;
+
+	return oss.str ( );
+}
+
+void run ( const std::string & prefixRankedType ) {
+	ext::vector < std::string > qs = {
+		gen ( prefixRankedType, "pattern" ),
+		"execute tree::properties::BorderArrayNaive $pattern > $res1",
+		"execute tree::properties::BorderArray      $pattern > $res2",
+		// "execute $pattern | string::Compose - ",
+		// "execute $res1",
+		// "execute $res2",
+		"quit compare::VectorCompare $res1 $res2",
+	};
+	for ( size_t i = 0; i < RANDOM_ITERATIONS; i++ )
+		TimeoutAqlTest ( 1s, qs );
+}
+
+TEST_CASE ( "Tree BorderArray", "[integration]" ) {
+	SECTION ( "PrefixRankedPattern" ) {
+		run ( "PrefixRankedPattern" );
+	}
+	SECTION ( "PrefixRankedBarPattern" ) {
+		run ( "PrefixRankedBarPattern" );
+	}
+	SECTION ( "PrefixRankedNonlinearPattern" ) {
+		run ( "PrefixRankedNonlinearPattern" );
+	}
+	SECTION ( "PrefixRankedBarNonlinearPattern" ) {
+		run ( "PrefixRankedBarNonlinearPattern" );
+	}
+}