Merge pull request #2 from yimmon/master

remove needless files

1 files changed, 0 insertions, 332 deletions

diff --git a/kaldi_io/src/tools/openfst/include/fst/tuple-weight.h b/kaldi_io/src/tools/openfst/include/fst/tuple-weight.h
deleted file mode 100644
index 184026c..0000000
--- a/kaldi_io/src/tools/openfst/include/fst/tuple-weight.h
+++ /dev/null
@@ -1,332 +0,0 @@
-// tuple-weight.h
-
-// 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.
-//
-// Copyright 2005-2010 Google, Inc.
-// Author: allauzen@google (Cyril Allauzen)
-//
-// \file
-// Tuple weight set operation definitions.
-
-#ifndef FST_LIB_TUPLE_WEIGHT_H__
-#define FST_LIB_TUPLE_WEIGHT_H__
-
-#include <string>
-#include <vector>
-using std::vector;
-
-#include <fst/weight.h>
-
-
-DECLARE_string(fst_weight_parentheses);
-DECLARE_string(fst_weight_separator);
-
-namespace fst {
-
-template<class W, unsigned int n> class TupleWeight;
-template <class W, unsigned int n>
-istream &operator>>(istream &strm, TupleWeight<W, n> &w);
-
-// n-tuple weight, element of the n-th catersian power of W
-template <class W, unsigned int n>
-class TupleWeight {
- public:
-  typedef TupleWeight<typename W::ReverseWeight, n> ReverseWeight;
-
-  TupleWeight() {}
-
-  TupleWeight(const TupleWeight &w) {
-    for (size_t i = 0; i < n; ++i)
-      values_[i] = w.values_[i];
-  }
-
-  template <class Iterator>
-  TupleWeight(Iterator begin, Iterator end) {
-    for (Iterator iter = begin; iter != end; ++iter)
-      values_[iter - begin] = *iter;
-  }
-
-  TupleWeight(const W &w) {
-    for (size_t i = 0; i < n; ++i)
-      values_[i] = w;
-  }
-
-  static const TupleWeight<W, n> &Zero() {
-    static const TupleWeight<W, n> zero(W::Zero());
-    return zero;
-  }
-
-  static const TupleWeight<W, n> &One() {
-    static const TupleWeight<W, n> one(W::One());
-    return one;
-  }
-
-  static const TupleWeight<W, n> &NoWeight() {
-    static const TupleWeight<W, n> no_weight(W::NoWeight());
-    return no_weight;
-  }
-
-  static unsigned int Length() {
-    return n;
-  }
-
-  istream &Read(istream &strm) {
-    for (size_t i = 0; i < n; ++i)
-      values_[i].Read(strm);
-    return strm;
-  }
-
-  ostream &Write(ostream &strm) const {
-    for (size_t i = 0; i < n; ++i)
-      values_[i].Write(strm);
-    return strm;
-  }
-
-  TupleWeight<W, n> &operator=(const TupleWeight<W, n> &w) {
-    for (size_t i = 0; i < n; ++i)
-      values_[i] = w.values_[i];
-    return *this;
-  }
-
-  bool Member() const {
-    bool member = true;
-    for (size_t i = 0; i < n; ++i)
-      member = member && values_[i].Member();
-    return member;
-  }
-
-  size_t Hash() const {
-    uint64 hash = 0;
-    for (size_t i = 0; i < n; ++i)
-      hash = 5 * hash + values_[i].Hash();
-    return size_t(hash);
-  }
-
-  TupleWeight<W, n> Quantize(float delta = kDelta) const {
-    TupleWeight<W, n> w;
-    for (size_t i = 0; i < n; ++i)
-      w.values_[i] = values_[i].Quantize(delta);
-    return w;
-  }
-
-  ReverseWeight Reverse() const {
-    TupleWeight<W, n> w;
-    for (size_t i = 0; i < n; ++i)
-      w.values_[i] = values_[i].Reverse();
-    return w;
-  }
-
-  const W& Value(size_t i) const { return values_[i]; }
-
-  void SetValue(size_t i, const W &w) { values_[i] = w; }
-
- protected:
-  // Reads TupleWeight when there are no parentheses around tuple terms
-  inline static istream &ReadNoParen(istream &strm,
-                                     TupleWeight<W, n> &w,
-                                     char separator) {
-    int c;
-    do {
-      c = strm.get();
-    } while (isspace(c));
-
-    for (size_t i = 0; i < n - 1; ++i) {
-      string s;
-      if (i)
-        c = strm.get();
-      while (c != separator) {
-        if (c == EOF) {
-          strm.clear(std::ios::badbit);
-          return strm;
-        }
-        s += c;
-        c = strm.get();
-      }
-      // read (i+1)-th element
-      istringstream sstrm(s);
-      W r = W::Zero();
-      sstrm >> r;
-      w.SetValue(i, r);
-    }
-
-    // read n-th element
-    W r = W::Zero();
-    strm >> r;
-    w.SetValue(n - 1, r);
-
-    return strm;
-  }
-
-  // Reads TupleWeight when there are parentheses around tuple terms
-  inline static istream &ReadWithParen(istream &strm,
-                                       TupleWeight<W, n> &w,
-                                       char separator,
-                                       char open_paren,
-                                       char close_paren) {
-    int c;
-    do {
-      c = strm.get();
-    } while (isspace(c));
-
-    if (c != open_paren) {
-      FSTERROR() << " is fst_weight_parentheses flag set correcty? ";
-      strm.clear(std::ios::badbit);
-      return strm;
-    }
-
-    for (size_t i = 0; i < n - 1; ++i) {
-      // read (i+1)-th element
-      stack<int> parens;
-      string s;
-      c = strm.get();
-      while (c != separator || !parens.empty()) {
-        if (c == EOF) {
-          strm.clear(std::ios::badbit);
-          return strm;
-        }
-        s += c;
-        // if parens encountered before separator, they must be matched
-        if (c == open_paren) {
-          parens.push(1);
-        } else if (c == close_paren) {
-          // Fail for mismatched parens
-          if (parens.empty()) {
-            strm.clear(std::ios::failbit);
-            return strm;
-          }
-          parens.pop();
-        }
-        c = strm.get();
-      }
-      istringstream sstrm(s);
-      W r = W::Zero();
-      sstrm >> r;
-      w.SetValue(i, r);
-    }
-
-    // read n-th element
-    string s;
-    c = strm.get();
-    while (c != EOF) {
-      s += c;
-      c = strm.get();
-    }
-    if (s.empty() || *s.rbegin() != close_paren) {
-      FSTERROR() << " is fst_weight_parentheses flag set correcty? ";
-      strm.clear(std::ios::failbit);
-      return strm;
-    }
-    s.erase(s.size() - 1, 1);
-    istringstream sstrm(s);
-    W r = W::Zero();
-    sstrm >> r;
-    w.SetValue(n - 1, r);
-
-    return strm;
-  }
-
-
- private:
-  W values_[n];
-
-  friend istream &operator>><W, n>(istream&, TupleWeight<W, n>&);
-};
-
-template <class W, unsigned int n>
-inline bool operator==(const TupleWeight<W, n> &w1,
-                       const TupleWeight<W, n> &w2) {
-  bool equal = true;
-  for (size_t i = 0; i < n; ++i)
-    equal = equal && (w1.Value(i) == w2.Value(i));
-  return equal;
-}
-
-template <class W, unsigned int n>
-inline bool operator!=(const TupleWeight<W, n> &w1,
-                       const TupleWeight<W, n> &w2) {
-  bool not_equal = false;
-  for (size_t i = 0; (i < n) && !not_equal; ++i)
-    not_equal = not_equal || (w1.Value(i) != w2.Value(i));
-  return not_equal;
-}
-
-template <class W, unsigned int n>
-inline bool ApproxEqual(const TupleWeight<W, n> &w1,
-                        const TupleWeight<W, n> &w2,
-                        float delta = kDelta) {
-  bool approx_equal = true;
-  for (size_t i = 0; i < n; ++i)
-    approx_equal = approx_equal &&
-        ApproxEqual(w1.Value(i), w2.Value(i), delta);
-  return approx_equal;
-}
-
-template <class W, unsigned int n>
-inline ostream &operator<<(ostream &strm, const TupleWeight<W, n> &w) {
-  if(FLAGS_fst_weight_separator.size() != 1) {
-    FSTERROR() << "FLAGS_fst_weight_separator.size() is not equal to 1";
-    strm.clear(std::ios::badbit);
-    return strm;
-  }
-  char separator = FLAGS_fst_weight_separator[0];
-  bool write_parens = false;
-  if (!FLAGS_fst_weight_parentheses.empty()) {
-    if (FLAGS_fst_weight_parentheses.size() != 2) {
-      FSTERROR() << "FLAGS_fst_weight_parentheses.size() is not equal to 2";
-      strm.clear(std::ios::badbit);
-      return strm;
-    }
-    write_parens = true;
-  }
-
-  if (write_parens)
-    strm << FLAGS_fst_weight_parentheses[0];
-  for (size_t i  = 0; i < n; ++i) {
-    if(i)
-      strm << separator;
-    strm << w.Value(i);
-  }
-  if (write_parens)
-    strm << FLAGS_fst_weight_parentheses[1];
-
-  return strm;
-}
-
-template <class W, unsigned int n>
-inline istream &operator>>(istream &strm, TupleWeight<W, n> &w) {
-  if(FLAGS_fst_weight_separator.size() != 1) {
-    FSTERROR() << "FLAGS_fst_weight_separator.size() is not equal to 1";
-    strm.clear(std::ios::badbit);
-    return strm;
-  }
-  char separator = FLAGS_fst_weight_separator[0];
-
-  if (!FLAGS_fst_weight_parentheses.empty()) {
-    if (FLAGS_fst_weight_parentheses.size() != 2) {
-      FSTERROR() << "FLAGS_fst_weight_parentheses.size() is not equal to 2";
-      strm.clear(std::ios::badbit);
-      return strm;
-    }
-    return TupleWeight<W, n>::ReadWithParen(
-        strm, w, separator, FLAGS_fst_weight_parentheses[0],
-        FLAGS_fst_weight_parentheses[1]);
-  } else {
-    return TupleWeight<W, n>::ReadNoParen(strm, w, separator);
-  }
-}
-
-
-
-}  // namespace fst
-
-#endif  // FST_LIB_TUPLE_WEIGHT_H__