// online/online-feat-test.cc
  
  // Copyright 2013   Daniel Povey
  
  // See ../../COPYING for clarification regarding multiple authors
  //
  // 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
  //
  // THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  // KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  // WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  // MERCHANTABLITY OR NON-INFRINGEMENT.
  // See the Apache 2 License for the specific language governing permissions and
  // limitations under the License.
  
  #include "online/online-feat-input.h"
  
  namespace kaldi {
  
  // This class is for testing and prototyping purposes, it
  // does not really do anything except wrap a matrix of features
  // in this class.  Note: it maintains a reference to the input
  // matrix, so be careful not to delete it while this object
  // Since this is intended for testing purposes, it may occasionally
  // "time out" and return fewer than requested
  class OnlineMatrixInput : public OnlineFeatInputItf {
   public:
    OnlineMatrixInput(const Matrix<BaseFloat> &feats):
        position_(0), feats_(feats) { }
  
    virtual int32 Dim() const { return feats_.NumCols(); }
    
    virtual bool Compute(Matrix<BaseFloat> *output) {
      if (feats_.NumRows() == 0) { // empty input.
        output->Resize(0, 0);
        return false;
      }
      
      KALDI_ASSERT(output->NumRows() > 0 &&
                   output->NumCols() == feats_.NumCols());
      
      // Because this is a kind of stress test, we completely ignore
      // the number of frames requested, and return whatever number of
      // frames we please.
  
      int32 num_frames_left = feats_.NumRows() - position_;
      int32 num_frames_return = std::min((Rand() % 5), num_frames_left);
      if (num_frames_return == 0) {
        output->Resize(0, 0);
      } else {
        output->Resize(num_frames_return, feats_.NumCols());
        output->CopyFromMat(feats_.Range(position_, num_frames_return,
                                         0, feats_.NumCols()));
      }
      position_ += num_frames_return;
      if (position_ == feats_.NumRows()) return false;
      else return true;
    }
  
   private:
    int32 position_;
    Matrix<BaseFloat> feats_;
  };
  
  template<class Real> static void AssertEqual(const Matrix<Real> &A,
                                               const Matrix<Real> &B,
                                               float tol = 0.001) {
    KALDI_ASSERT(A.NumRows() == B.NumRows()&&A.NumCols() == B.NumCols());
    for (MatrixIndexT i = 0;i < A.NumRows();i++)
      for (MatrixIndexT j = 0;j < A.NumCols();j++) {
        KALDI_ASSERT(std::abs(A(i, j)-B(i, j)) < tol*std::max(1.0, (double) (std::abs(A(i, j))+std::abs(B(i, j)))));
      }
  }
  
  // This function will crash if the two objects do not
  // give the same output.
  void GetOutput(OnlineFeatInputItf *a,
                 Matrix<BaseFloat> *output) {
    int32 dim = a->Dim();
    OnlineCacheInput cache(a);
    while (true) {
      Matrix<BaseFloat> garbage;
      int32 batch_size = 1 + Rand() % 10;
      garbage.Resize(batch_size, dim); // some random requested amount.
      if (!cache.Compute(&garbage)) // returns false when done.
        break;
    }
    cache.GetCachedData(output);
  }
  
  // test the MatrixInput and CacheInput classes.
  void TestOnlineMatrixInput() {
    int32 dim = 2 + Rand() % 5; // dimension of features.
    int32 num_frames = 100 + Rand() % 100;
  
    Matrix<BaseFloat> input_feats(num_frames, dim);
    input_feats.SetRandn();
  
    OnlineMatrixInput matrix_input(input_feats);
    
    Matrix<BaseFloat> output_feats;
    GetOutput(&matrix_input, &output_feats);
    AssertEqual(input_feats, output_feats);
  }
  
  void TestOnlineFeatureMatrix() {
    int32 dim = 2 + Rand() % 5; // dimension of features.
    int32 num_frames = 100 + Rand() % 100;
  
    Matrix<BaseFloat> input_feats(num_frames, dim);
    input_feats.SetRandn();
  
    OnlineMatrixInput matrix_input(input_feats);
    OnlineFeatureMatrixOptions opts;
    opts.num_tries = 100; // makes it very unlikely we'll get that many timeouts.
    OnlineFeatureMatrix online_feature_matrix(opts, &matrix_input);
  
    for (int32 frame = 0; frame < num_frames; frame++) {
      KALDI_ASSERT(online_feature_matrix.IsValidFrame(frame));
      KALDI_ASSERT(online_feature_matrix.GetFrame(frame).ApproxEqual(input_feats.Row(frame)));
    }
    KALDI_ASSERT(!online_feature_matrix.IsValidFrame(num_frames));
  }
  
  
  
  void TestOnlineLdaInput() {
    int32 dim = 2 + Rand() % 5; // dimension of features.
    int32 num_frames = 100 + Rand() % 100;
    int32 left_context = Rand() % 3, right_context = Rand() % 3;
    bool have_offset = (Rand() % 2 == 0);
    int32 lda_input_dim = (dim * (left_context + 1 + right_context)),
        lda_output_dim = 1 + Rand() % 5; // this can even be more than
         // the input dim, the class doesn't care.
    
    Matrix<BaseFloat> transform(lda_output_dim, lda_input_dim +
                                (have_offset ? 1 : 0));
    transform.SetRandn();
    Matrix<BaseFloat> input_feats(num_frames, dim);
    input_feats.SetRandn();
  
    OnlineMatrixInput matrix_input(input_feats);
    OnlineLdaInput lda_input(&matrix_input, transform, left_context, right_context);
  
    Matrix<BaseFloat> output_feats1;
    GetOutput(&lda_input, &output_feats1);
    Matrix<BaseFloat> temp_feats;
    SpliceFrames(input_feats, left_context, right_context, &temp_feats);
    Matrix<BaseFloat> output_feats2(temp_feats.NumRows(), transform.NumRows());
    if (!have_offset) {
      output_feats2.AddMatMat(1.0, temp_feats, kNoTrans, transform, kTrans, 0.0);
    } else {
      SubMatrix<BaseFloat> linear_part(transform, 0, transform.NumRows(),
                                       0, transform.NumCols() - 1);
      output_feats2.AddMatMat(1.0, temp_feats, kNoTrans, linear_part, kTrans, 0.0);
      Vector<BaseFloat> offset(transform.NumRows());
      offset.CopyColFromMat(transform, transform.NumCols() - 1);
      output_feats2.AddVecToRows(1.0, offset);
    }
    KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
  }
  
  
  void TestOnlineDeltaInput() {
    int32 dim = 2 + Rand() % 5; // dimension of features.
    int32 num_frames = 100 + Rand() % 100;
    DeltaFeaturesOptions opts;
    opts.order = Rand() % 3;
    opts.window = 1 + Rand() % 3;
  
    int32 output_dim = dim * (1 + opts.order);
    
    Matrix<BaseFloat> input_feats(num_frames, dim);
    input_feats.SetRandn();
    
    OnlineMatrixInput matrix_input(input_feats);
    OnlineDeltaInput delta_input(opts, &matrix_input);
  
    Matrix<BaseFloat> output_feats1;
    GetOutput(&delta_input, &output_feats1);
  
    Matrix<BaseFloat> output_feats2(num_frames, output_dim);
    ComputeDeltas(opts, input_feats, &output_feats2);
  
    KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
  }
  
  
  void TestOnlineCmnInput() { // We're also testing OnlineCacheInput here.
    int32 dim = 2 + Rand() % 5; // dimension of features.
    int32 num_frames = 10 + Rand() % 10;
    
    Matrix<BaseFloat> input_feats(num_frames, dim);
    input_feats.SetRandn();
  
    OnlineMatrixInput matrix_input(input_feats);
    int32 cmn_window = 10 + Rand() % 20;
    int32 min_window = 1 + Rand() % (cmn_window - 1);
    if (Rand() % 3 == 0) min_window = cmn_window;
    
    OnlineCmnInput cmn_input(&matrix_input, cmn_window,
                             min_window);
    OnlineCacheInput cache_input(&cmn_input);
    
    Matrix<BaseFloat> output_feats1;
    GetOutput(&cache_input, &output_feats1);
    
    Matrix<BaseFloat> output_feats2(input_feats);
    for (int32 i = 0; i < output_feats2.NumRows(); i++) {
      SubVector<BaseFloat> this_row(output_feats2, i);
      if (i == 0 && min_window == 0) this_row.SetZero();
      else if (i < min_window) {
        int32 window_nframes = std::min(min_window, input_feats.NumRows());
        Vector<BaseFloat> this_sum(dim);
        SubMatrix<BaseFloat> this_block(input_feats, 0, window_nframes,
                                        0, dim);
        this_sum.AddRowSumMat(1.0, this_block, 0.0);
        this_row.AddVec(-1.0 / window_nframes, this_sum);
      } else {
        int32 window_nframes = std::min(i, cmn_window);
        Vector<BaseFloat> this_sum(dim);
        SubMatrix<BaseFloat> this_block(input_feats, i - window_nframes, window_nframes,
                                        0, dim);
        this_sum.AddRowSumMat(1.0, this_block, 0.0);
        this_row.AddVec(-1.0 / window_nframes, this_sum);
      }
    }
    KALDI_ASSERT(output_feats1.NumRows() == output_feats2.NumRows());
    for (int32 i = 0; i < output_feats2.NumRows(); i++) {
      if (!output_feats1.Row(i).ApproxEqual(output_feats2.Row(i))) {
        KALDI_ERR << "Rows differ " << i << ", " << input_feats.Row(i) << output_feats1.Row(i)
                  << output_feats2.Row(i);
      }
    }
    KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
    Matrix<BaseFloat> output_feats3;
    cache_input.GetCachedData(&output_feats3);
    KALDI_ASSERT(output_feats1.ApproxEqual(output_feats3));
  }
  
  
  
  }  // end namespace kaldi
  
  int main() {
    using namespace kaldi;
    for (int i = 0; i < 40; i++) {
      TestOnlineMatrixInput();
      TestOnlineFeatureMatrix();
      TestOnlineLdaInput();
      TestOnlineDeltaInput();
      TestOnlineCmnInput(); // also tests cache input.
      // I have not tested the delta input yet.
    }
    std::cout << "Test OK.
  ";
  }