Implement topological sort. (k2-fsa#18)

Author: csukuangfj

cmake/googletest.cmake

@@ -33,6 +33,25 @@ function(download_googltest)
   message(STATUS "googletest is downloaded to ${googletest_SOURCE_DIR}")
   message(STATUS "googletest's binary dir is ${googletest_BINARY_DIR}")
 
+  if(APPLE)
+    set(CMAKE_MACOSX_RPATH ON) # to solve the following warning on macOS
+  endif()
+  #[==[
+  -- Generating done
+    Policy CMP0042 is not set: MACOSX_RPATH is enabled by default.  Run "cmake
+    --help-policy CMP0042" for policy details.  Use the cmake_policy command to
+    set the policy and suppress this warning.
+
+    MACOSX_RPATH is not specified for the following targets:
+
+      gmock
+      gmock_main
+      gtest
+      gtest_main
+
+  This warning is for project developers.  Use -Wno-dev to suppress it.
+  ]==]
+
   add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR} EXCLUDE_FROM_ALL)
 
   target_include_directories(gtest

k2/csrc/CMakeLists.txt

@@ -25,7 +25,6 @@ function(k2_add_fsa_test name)
       gtest
       gtest_main
   )
-
   add_test(NAME "Test.${name}"
     COMMAND
       $<TARGET_FILE:${name}>

k2/csrc/fsa_algo.cc

@@ -13,6 +13,7 @@
 #include <utility>
 
 #include "glog/logging.h"
+#include "k2/csrc/properties.h"
 
 namespace {
 
@@ -57,7 +58,7 @@ void ConnectCore(const Fsa &fsa, std::vector<int32_t> *state_map) {
       auto state = current_state.state;  // get a copy since we will destroy it
       stack.pop();
       if (!stack.empty()) {
-        // if it has a parent, set the parent's coaccessible flag
+        // if it has a parent, set the parent's co-accessible flag
         if (coaccessible[state]) {
           auto &parent = stack.top();
           coaccessible[parent.state] = true;
@@ -98,7 +99,7 @@ void ConnectCore(const Fsa &fsa, std::vector<int32_t> *state_map) {
 
 void Connect(const Fsa &a, Fsa *b, std::vector<int32_t> *arc_map /*=nullptr*/) {
   CHECK_NOTNULL(b);
-  if (arc_map) arc_map->clear();
+  if (arc_map != nullptr) arc_map->clear();
 
   std::vector<int32_t> state_b_to_a;
   ConnectCore(a, &state_b_to_a);
@@ -108,7 +109,7 @@ void Connect(const Fsa &a, Fsa *b, std::vector<int32_t> *arc_map /*=nullptr*/) {
   b->arcs.clear();
   b->arcs.reserve(a.arcs.size());
 
-  if (arc_map) {
+  if (arc_map != nullptr) {
     arc_map->clear();
     arc_map->reserve(a.arcs.size());
   }
@@ -144,9 +145,7 @@ void Connect(const Fsa &a, Fsa *b, std::vector<int32_t> *arc_map /*=nullptr*/) {
       arc.src_state = i;
       arc.dest_state = state_b;
       b->arcs.push_back(arc);
-      if (arc_map) {
-        arc_map->push_back(arc_begin);
-      }
+      if (arc_map != nullptr) arc_map->push_back(arc_begin);
     }
   }
 }
@@ -194,4 +193,112 @@ void ArcSort(const Fsa &a, Fsa *b,
   }
   if (arc_map != nullptr) arc_map->swap(indexes);
 }
+
+bool TopSort(const Fsa &a, Fsa *b,
+             std::vector<int32_t> *state_map /*= nullptr*/) {
+  CHECK_NOTNULL(b);
+  b->arc_indexes.clear();
+  b->arcs.clear();
+
+  if (state_map != nullptr) state_map->clear();
+
+  if (IsEmpty(a)) return true;
+  if (!IsConnected(a)) return false;
+
+  static constexpr int8_t kNotVisited = 0;  // a node that has not been visited
+  static constexpr int8_t kVisiting = 1;    // a node that is under visiting
+  static constexpr int8_t kVisited = 2;     // a node that has been visited
+
+  auto num_states = a.NumStates();
+  auto final_state = num_states - 1;
+  std::vector<int8_t> state_status(num_states, kNotVisited);
+
+  // map order to state.
+  // state 0 has the largest order, i.e., num_states - 1
+  // final_state has the least order, i.e., 0
+  std::vector<int32_t> order;
+  order.reserve(num_states);
+
+  std::stack<DfsState> stack;
+  stack.push({0, a.arc_indexes[0], a.arc_indexes[1]});
+  state_status[0] = kVisiting;
+  bool is_acyclic = true;
+  while (is_acyclic && !stack.empty()) {
+    auto &current_state = stack.top();
+    if (current_state.arc_begin == current_state.arc_end) {
+      // we have finished visiting this state
+      state_status[current_state.state] = kVisited;
+      order.push_back(current_state.state);
+      stack.pop();
+      continue;
+    }
+    const auto &arc = a.arcs[current_state.arc_begin];
+    auto next_state = arc.dest_state;
+    auto status = state_status[next_state];
+    switch (status) {
+      case kNotVisited: {
+        // a new discovered node
+        state_status[next_state] = kVisiting;
+        auto arc_begin = a.arc_indexes[next_state];
+        if (next_state != final_state)
+          stack.push({next_state, arc_begin, a.arc_indexes[next_state + 1]});
+        else
+          stack.push({next_state, arc_begin, arc_begin});
+        ++current_state.arc_begin;
+        break;
+      }
+      case kVisiting:
+        // this is a back arc indicating a loop in the graph
+        is_acyclic = false;
+        break;
+      case kVisited:
+        // this is a forward cross arc, do nothing.
+        ++current_state.arc_begin;
+        break;
+      default:
+        LOG(FATAL) << "Unreachable code is executed!";
+        break;
+    }
+  }
+
+  if (!is_acyclic) return false;
+
+  std::vector<int32_t> state_a_to_b(num_states);
+  for (auto i = 0; i != num_states; ++i) {
+    state_a_to_b[order[num_states - 1 - i]] = i;
+  }
+
+  // start state maps to start state
+  CHECK_EQ(state_a_to_b.front(), 0);
+  // final state maps to final state
+  CHECK_EQ(state_a_to_b.back(), final_state);
+
+  b->arcs.reserve(a.arc_indexes.size());
+  b->arc_indexes.resize(num_states);
+
+  int32_t arc_begin;
+  int32_t arc_end;
+  for (auto state_b = 0; state_b != num_states; ++state_b) {
+    auto state_a = order[num_states - 1 - state_b];
+    arc_begin = a.arc_indexes[state_a];
+    if (state_a != final_state)
+      arc_end = a.arc_indexes[state_a + 1];
+    else
+      arc_end = arc_begin;
+
+    b->arc_indexes[state_b] = static_cast<int32_t>(b->arcs.size());
+    for (; arc_begin != arc_end; ++arc_begin) {
+      auto arc = a.arcs[arc_begin];
+      arc.src_state = state_b;
+      arc.dest_state = state_a_to_b[arc.dest_state];
+      b->arcs.push_back(arc);
+    }
+  }
+  if (state_map != nullptr) {
+    std::reverse(order.begin(), order.end());
+    state_map->swap(order);
+  }
+  return true;
+}
+
 }  // namespace k2

k2/csrc/fsa_algo.h

@@ -213,6 +213,24 @@ void RandomPath(const Fsa &a, const float *a_cost, Fsa *b,
                               arc indexes in input fsa.
  */
 void ArcSort(const Fsa &a, Fsa *b, std::vector<int32_t> *arc_map = nullptr);
+/**
+    Sort the input fsa topologically.
+
+    It returns an empty fsa when the input fsa is not acyclic,
+    is not connected, or is empty; otherwise it returns the topologically
+    sorted fsa in `b`.
+
+    @param [in]   a   Input fsa to be topo sorted.
+    @param [out]  b   Output fsa. It is set to empty if the input fsa is not
+                      acyclic or is not connected; otherwise it contains the
+                      topo sorted fsa.
+    @param [out]  state_map   Maps from state indexes in the output fsa to
+                              state indexes in input fsa. It is empty if
+                              the output fsa is empty.
+    @return true if the input fsa is acyclic and connected,
+            or if the input is empty; return false otherwise.
+ */
+bool TopSort(const Fsa& a, Fsa* b, std::vector<int32_t>* state_map = nullptr);
 
 /**
 

k2/csrc/fsa_algo_test.cc

@@ -7,11 +7,14 @@
 
 #include "k2/csrc/fsa_algo.h"
 
+#include <string>
 #include <utility>
 #include <vector>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "k2/csrc/fsa_renderer.h"
+#include "k2/csrc/fsa_util.h"
 
 namespace k2 {
 
@@ -142,4 +145,99 @@ TEST(FsaAlgo, ArcSort) {
   }
 }
 
+TEST(FsaAlgo, TopSort) {
+  {
+    // case 1: empty input fsa
+    Fsa fsa;
+    Fsa top_sorted;
+    std::vector<int32_t> state_map(10);
+    bool status = TopSort(fsa, &top_sorted, &state_map);
+
+    EXPECT_TRUE(status);
+    EXPECT_TRUE(IsEmpty(top_sorted));
+    EXPECT_TRUE(state_map.empty());
+  }
+
+  {
+    // case 2: non-connected fsa (not co-accessible)
+    std::string s = R"(
+0 2 3
+1 2 1
+2
+)";
+    auto fsa = StringToFsa(s);
+    ASSERT_NE(fsa.get(), nullptr);
+
+    Fsa top_sorted;
+    std::vector<int32_t> state_map(10);
+    bool status = TopSort(*fsa, &top_sorted, &state_map);
+
+    EXPECT_FALSE(status);
+    EXPECT_TRUE(IsEmpty(top_sorted));
+    EXPECT_TRUE(state_map.empty());
+  }
+
+  {
+    // case 3: non-connected fsa (not accessible)
+    std::string s = R"(
+0 2 3
+1 0 1
+2
+)";
+    auto fsa = StringToFsa(s);
+    ASSERT_NE(fsa.get(), nullptr);
+
+    Fsa top_sorted;
+    std::vector<int32_t> state_map(10);
+    bool status = TopSort(*fsa, &top_sorted, &state_map);
+
+    EXPECT_FALSE(status);
+    EXPECT_TRUE(IsEmpty(top_sorted));
+    EXPECT_TRUE(state_map.empty());
+  }
+
+  {
+    // case 4: connected fsa
+    std::string s = R"(
+0 4 40
+0 2 20
+1 6 2
+2 3 30
+3 6 60
+3 1 10
+4 5 50
+5 2 8
+6
+)";
+    auto fsa = StringToFsa(s);
+    ASSERT_NE(fsa.get(), nullptr);
+
+    Fsa top_sorted;
+    std::vector<int32_t> state_map;
+
+    TopSort(*fsa, &top_sorted, &state_map);
+
+    ASSERT_EQ(top_sorted.NumStates(), fsa->NumStates());
+
+    ASSERT_FALSE(state_map.empty());
+    EXPECT_THAT(state_map, ::testing::ElementsAre(0, 4, 5, 2, 3, 1, 6));
+
+    ASSERT_FALSE(IsEmpty(top_sorted));
+
+    const auto &arc_indexes = top_sorted.arc_indexes;
+    const auto &arcs = top_sorted.arcs;
+
+    ASSERT_EQ(arc_indexes.size(), 7u);
+    EXPECT_THAT(arc_indexes, ::testing::ElementsAre(0, 2, 3, 4, 5, 7, 8));
+    std::vector<Arc> expected_arcs = {
+        {0, 1, 40}, {0, 3, 20}, {1, 2, 50}, {2, 3, 8},
+        {3, 4, 30}, {4, 6, 60}, {4, 5, 10}, {5, 6, 2},
+    };
+
+    for (auto i = 0; i != 8; ++i) {
+      EXPECT_EQ(arcs[i], expected_arcs[i]);
+    }
+  }
+}
+
 }  // namespace k2