1 files changed, 0 insertions, 225 deletions
diff --git a/kaldi_io/src/tools/openfst/include/fst/sparse-power-weight.h b/kaldi_io/src/tools/openfst/include/fst/sparse-power-weight.h
deleted file mode 100644
index a1ff56a..0000000
--- a/kaldi_io/src/tools/openfst/include/fst/sparse-power-weight.h
+++ /dev/null
@@ -1,225 +0,0 @@
-// sparse-power-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: [email protected] (Kasturi Rangan Raghavan)
-// Inspiration: [email protected] (Cyril Allauzen)
-//
-// \file
-// Cartesian power weight semiring operation definitions.
-// Uses SparseTupleWeight as underlying representation.
-
-#ifndef FST_LIB_SPARSE_POWER_WEIGHT_H__
-#define FST_LIB_SPARSE_POWER_WEIGHT_H__
-
-#include<string>
-
-#include <fst/sparse-tuple-weight.h>
-#include <fst/weight.h>
-
-
-namespace fst {
-
-// Below SparseTupleWeight*Mapper are used in conjunction with
-// SparseTupleWeightMap to compute the respective semiring operations
-template<class W, class K>
-struct SparseTupleWeightPlusMapper {
- W Map(const K& k, const W& v1, const W& v2) const {
- return Plus(v1, v2);
- }
-};
-
-template<class W, class K>
-struct SparseTupleWeightTimesMapper {
- W Map(const K& k, const W& v1, const W& v2) const {
- return Times(v1, v2);
- }
-};
-
-template<class W, class K>
-struct SparseTupleWeightDivideMapper {
- SparseTupleWeightDivideMapper(DivideType divide_type) {
- divide_type_ = divide_type;
- }
- W Map(const K& k, const W& v1, const W& v2) const {
- return Divide(v1, v2, divide_type_);
- }
- DivideType divide_type_;
-};
-
-template<class W, class K>
-struct SparseTupleWeightApproxMapper {
- SparseTupleWeightApproxMapper(float delta) { delta_ = delta; }
- W Map(const K& k, const W& v1, const W& v2) const {
- return ApproxEqual(v1, v2, delta_) ? W::One() : W::Zero();
- }
- float delta_;
-};
-
-// Sparse cartesian power semiring: W ^ n
-// Forms:
-// - a left semimodule when W is a left semiring,
-// - a right semimodule when W is a right semiring,
-// - a bisemimodule when W is a semiring,
-// the free semimodule of rank n over W
-// The Times operation is overloaded to provide the
-// left and right scalar products.
-// K is the key value type. kNoKey(-1) is reserved for internal use
-template <class W, class K = int>
-class SparsePowerWeight : public SparseTupleWeight<W, K> {
- public:
- using SparseTupleWeight<W, K>::Zero;
- using SparseTupleWeight<W, K>::One;
- using SparseTupleWeight<W, K>::NoWeight;
- using SparseTupleWeight<W, K>::Quantize;
- using SparseTupleWeight<W, K>::Reverse;
-
- typedef SparsePowerWeight<typename W::ReverseWeight, K> ReverseWeight;
-
- SparsePowerWeight() {}
-
- SparsePowerWeight(const SparseTupleWeight<W, K> &w) :
- SparseTupleWeight<W, K>(w) { }
-
- template <class Iterator>
- SparsePowerWeight(Iterator begin, Iterator end) :
- SparseTupleWeight<W, K>(begin, end) { }
-
- SparsePowerWeight(const K &key, const W &w) :
- SparseTupleWeight<W, K>(key, w) { }
-
- static const SparsePowerWeight<W, K> &Zero() {
- static const SparsePowerWeight<W, K> zero(SparseTupleWeight<W, K>::Zero());
- return zero;
- }
-
- static const SparsePowerWeight<W, K> &One() {
- static const SparsePowerWeight<W, K> one(SparseTupleWeight<W, K>::One());
- return one;
- }
-
- static const SparsePowerWeight<W, K> &NoWeight() {
- static const SparsePowerWeight<W, K> no_weight(
- SparseTupleWeight<W, K>::NoWeight());
- return no_weight;
- }
-
- // Overide this: Overwrite the Type method to reflect the key type
- // if using non-default key type.
- static const string &Type() {
- static string type;
- if(type.empty()) {
- type = W::Type() + "_^n";
- if(sizeof(K) != sizeof(uint32)) {
- string size;
- Int64ToStr(8 * sizeof(K), &size);
- type += "_" + size;
- }
- }
- return type;
- }
-
- static uint64 Properties() {
- uint64 props = W::Properties();
- return props & (kLeftSemiring | kRightSemiring |
- kCommutative | kIdempotent);
- }
-
- SparsePowerWeight<W, K> Quantize(float delta = kDelta) const {
- return SparseTupleWeight<W, K>::Quantize(delta);
- }
-
- ReverseWeight Reverse() const {
- return SparseTupleWeight<W, K>::Reverse();
- }
-};
-
-// Semimodule plus operation
-template <class W, class K>
-inline SparsePowerWeight<W, K> Plus(const SparsePowerWeight<W, K> &w1,
- const SparsePowerWeight<W, K> &w2) {
- SparsePowerWeight<W, K> ret;
- SparseTupleWeightPlusMapper<W, K> operator_mapper;
- SparseTupleWeightMap(&ret, w1, w2, operator_mapper);
- return ret;
-}
-
-// Semimodule times operation
-template <class W, class K>
-inline SparsePowerWeight<W, K> Times(const SparsePowerWeight<W, K> &w1,
- const SparsePowerWeight<W, K> &w2) {
- SparsePowerWeight<W, K> ret;
- SparseTupleWeightTimesMapper<W, K> operator_mapper;
- SparseTupleWeightMap(&ret, w1, w2, operator_mapper);
- return ret;
-}
-
-// Semimodule divide operation
-template <class W, class K>
-inline SparsePowerWeight<W, K> Divide(const SparsePowerWeight<W, K> &w1,
- const SparsePowerWeight<W, K> &w2,
- DivideType type = DIVIDE_ANY) {
- SparsePowerWeight<W, K> ret;
- SparseTupleWeightDivideMapper<W, K> operator_mapper(type);
- SparseTupleWeightMap(&ret, w1, w2, operator_mapper);
- return ret;
-}
-
-// Semimodule dot product
-template <class W, class K>
-inline const W& DotProduct(const SparsePowerWeight<W, K> &w1,
- const SparsePowerWeight<W, K> &w2) {
- const SparsePowerWeight<W, K>& product = Times(w1, w2);
- W ret(W::Zero());
- for (SparseTupleWeightIterator<W, K> it(product); !it.Done(); it.Next()) {
- ret = Plus(ret, it.Value().second);
- }
- return ret;
-}
-
-template <class W, class K>
-inline bool ApproxEqual(const SparsePowerWeight<W, K> &w1,
- const SparsePowerWeight<W, K> &w2,
- float delta = kDelta) {
- SparseTupleWeight<W, K> ret;
- SparseTupleWeightApproxMapper<W, K> operator_mapper(kDelta);
- SparseTupleWeightMap(&ret, w1, w2, operator_mapper);
- return ret == SparsePowerWeight<W, K>::One();
-}
-
-template <class W, class K>
-inline SparsePowerWeight<W, K> Times(const W &k,
- const SparsePowerWeight<W, K> &w2) {
- SparsePowerWeight<W, K> w1(k);
- return Times(w1, w2);
-}
-
-template <class W, class K>
-inline SparsePowerWeight<W, K> Times(const SparsePowerWeight<W, K> &w1,
- const W &k) {
- SparsePowerWeight<W, K> w2(k);
- return Times(w1, w2);
-}
-
-template <class W, class K>
-inline SparsePowerWeight<W, K> Divide(const SparsePowerWeight<W, K> &w1,
- const W &k,
- DivideType divide_type = DIVIDE_ANY) {
- SparsePowerWeight<W, K> w2(k);
- return Divide(w1, w2, divide_type);
-}
-
-} // namespace fst
-
-#endif // FST_LIB_SPARSE_POWER_WEIGHT_H__