;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; LUSH Lisp Universal Shell
;;;   Copyright (C) 2002 Leon Bottou, Yann Le Cun, AT&T Corp, NECI.
;;; Includes parts of TL3:
;;;   Copyright (C) 1987-1999 Leon Bottou and Neuristique.
;;; Includes selected parts of SN3.2:
;;;   Copyright (C) 1991-2001 AT&T Corp.
;;;
;;; Includes information derived from the GSL (Gnu Scientific Library)
;;;   header files which are copyrighted and distributed under the GPL
;;;   by their respective authors.
;;;
;;; This program is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 2 of the License, or
;;; (at your option) any later version.
;;;
;;; This program is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with this program; if not, write to the Free Software
;;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(libload "torch/torch-config")
(libload "torch/level3")


#? *** level4

;; dummy function that adds torch header files in C file
(eval `(de dummy_level4 () ,torch-cpheader-cmd ()))

#? * torch_mlp
;;.TYPE CLASS
#? (==> <torch_mlp> get_layers)
#? (==> <torch_mlp> set_layers <s>)
#? (==> <torch_mlp> get_n_layers)
#? (==> <torch_mlp> set_n_layers <s>)
#? (==> <torch_mlp> get_is_linear)
#? (==> <torch_mlp> set_is_linear <s>)
#? (==> <torch_mlp> setweightdecay <weight_decay>)
#? (==> <torch_mlp> -destructor)

#? * torch_classnllcriterion
;;.TYPE CLASS
#? (==> <torch_classnllcriterion> get_class_format)
#? (==> <torch_classnllcriterion> set_class_format <s>)
#? (new torch_classnllcriterion <flag> <class_format>>
#? (==> <torch_classnllcriterion> frameforward <s> <f_inputs> <f_outputs>)
#? (==> <torch_classnllcriterion> framebackward <s> <f_inputs> <beta_> <f_outputs> <alpha_>)
#? (==> <torch_classnllcriterion> -destructor)

#? * torch_msecriterion
;;.TYPE CLASS
#? (==> <torch_msecriterion> get_average_frame_size)
#? (==> <torch_msecriterion> set_average_frame_size <s>)
#? (new torch_msecriterion <flag> <n_inputs_>>
#? (==> <torch_msecriterion> frameforward <s> <f_inputs> <f_outputs>)
#? (==> <torch_msecriterion> framebackward <s> <f_inputs> <beta_> <f_outputs> <alpha_>)
#? (==> <torch_msecriterion> -destructor)

#? * torch_multicriterion
;;.TYPE CLASS
#? (==> <torch_multicriterion> get_n_criterions)
#? (==> <torch_multicriterion> set_n_criterions <s>)
#? (==> <torch_multicriterion> get_criterions)
#? (==> <torch_multicriterion> set_criterions <s>)
#? (==> <torch_multicriterion> get_weights)
#? (==> <torch_multicriterion> set_weights <s>)
#? (new torch_multicriterion <flag> <criterions_> <n_criterions_> <weights_>>
#? (==> <torch_multicriterion> forward <inputs>)
#? (==> <torch_multicriterion> backward <inputs> <alpha>)
#? (==> <torch_multicriterion> setdataset <data_>)
#? (==> <torch_multicriterion> iterinitialize)
#? (==> <torch_multicriterion> reset)
#? (==> <torch_multicriterion> -destructor)

#? * torch_nllcriterion
;;.TYPE CLASS
#? (new torch_nllcriterion <flag>>
#? (==> <torch_nllcriterion> reset)
#? (==> <torch_nllcriterion> forward <inputs>)
#? (==> <torch_nllcriterion> backward <inputs> <alpha>)
#? (==> <torch_nllcriterion> -destructor)

#? * torch_weightedmsecriterion
;;.TYPE CLASS
#? (==> <torch_weightedmsecriterion> get_average_frame_size)
#? (==> <torch_weightedmsecriterion> set_average_frame_size <s>)
#? (==> <torch_weightedmsecriterion> get_weights)
#? (==> <torch_weightedmsecriterion> set_weights <s>)
#? (new torch_weightedmsecriterion <flag> <data_>>
#? (new torch_weightedmsecriterion <flag> <data_> <weights_>>
#? (==> <torch_weightedmsecriterion> setdataset <data_>)
#? (==> <torch_weightedmsecriterion> frameforward <s> <f_inputs> <f_outputs>)
#? (==> <torch_weightedmsecriterion> framebackward <s> <f_inputs> <beta_> <f_outputs> <alpha_>)
#? (==> <torch_weightedmsecriterion> -destructor)

#? * torch_diagonalgmm
;;.TYPE CLASS
#? (==> <torch_diagonalgmm> get_n_gaussians)
#? (==> <torch_diagonalgmm> set_n_gaussians <s>)
#? (==> <torch_diagonalgmm> get_prior_weights)
#? (==> <torch_diagonalgmm> set_prior_weights <s>)
#? (==> <torch_diagonalgmm> get_initial_kmeans_trainer)
#? (==> <torch_diagonalgmm> set_initial_kmeans_trainer <s>)
#? (==> <torch_diagonalgmm> get_initial_kmeans_trainer_measurers)
#? (==> <torch_diagonalgmm> set_initial_kmeans_trainer_measurers <s>)
#? (==> <torch_diagonalgmm> get_log_weights)
#? (==> <torch_diagonalgmm> set_log_weights <s>)
#? (==> <torch_diagonalgmm> get_means)
#? (==> <torch_diagonalgmm> set_means <s>)
#? (==> <torch_diagonalgmm> get_var)
#? (==> <torch_diagonalgmm> set_var <s>)
#? (==> <torch_diagonalgmm> get_dlog_weights)
#? (==> <torch_diagonalgmm> set_dlog_weights <s>)
#? (==> <torch_diagonalgmm> get_dmeans)
#? (==> <torch_diagonalgmm> set_dmeans <s>)
#? (==> <torch_diagonalgmm> get_dvar)
#? (==> <torch_diagonalgmm> set_dvar <s>)
#? (==> <torch_diagonalgmm> get_var_threshold)
#? (==> <torch_diagonalgmm> set_var_threshold <s>)
#? (==> <torch_diagonalgmm> get_log_probabilities_g)
#? (==> <torch_diagonalgmm> set_log_probabilities_g <s>)
#? (==> <torch_diagonalgmm> get_sum_log_var_plus_n_obs_log_2_pi)
#? (==> <torch_diagonalgmm> set_sum_log_var_plus_n_obs_log_2_pi <s>)
#? (==> <torch_diagonalgmm> get_minus_half_over_var)
#? (==> <torch_diagonalgmm> set_minus_half_over_var <s>)
#? (==> <torch_diagonalgmm> get_means_acc)
#? (==> <torch_diagonalgmm> set_means_acc <s>)
#? (==> <torch_diagonalgmm> get_var_acc)
#? (==> <torch_diagonalgmm> set_var_acc <s>)
#? (==> <torch_diagonalgmm> get_weights_acc)
#? (==> <torch_diagonalgmm> set_weights_acc <s>)
#? (new torch_diagonalgmm <flag> <n_inputs_> <n_gaussians_> <initial_kmeans_trainer_>>
#? (==> <torch_diagonalgmm> reset)
#? (==> <torch_diagonalgmm> setdataset <data_>)
#? (==> <torch_diagonalgmm> setvarthreshold <var_threshold_>)
#? (==> <torch_diagonalgmm> display)
#? (==> <torch_diagonalgmm> emiterinitialize)
#? (==> <torch_diagonalgmm> iterinitialize)
#? (==> <torch_diagonalgmm> framelogprobability <s> <inputs>)
#? (==> <torch_diagonalgmm> viterbiframelogprobability <s> <inputs>)
#? (==> <torch_diagonalgmm> framelogprobabilityonegaussian <g> <inputs>)
#? (==> <torch_diagonalgmm> sequenceinitialize <inputs>)
#? (==> <torch_diagonalgmm> emsequenceinitialize <inputs>)
#? (==> <torch_diagonalgmm> frameemaccposteriors <s> <inputs> <log_posterior>)
#? (==> <torch_diagonalgmm> frameviterbiaccposteriors <s> <inputs> <log_posterior>)
#? (==> <torch_diagonalgmm> emupdate)
#? (==> <torch_diagonalgmm> framebackward <s> <f_inputs> <beta_> <f_outputs> <alpha_>)
#? (==> <torch_diagonalgmm> frameexpectation <s> <inputs>)
#? (==> <torch_diagonalgmm> setngaussians <n_gaussians_>)
#? (==> <torch_diagonalgmm> -destructor)

#? * torch_hmm
;;.TYPE CLASS
#? (==> <torch_hmm> get_n_states)
#? (==> <torch_hmm> set_n_states <s>)
#? (==> <torch_hmm> get_prior_transitions)
#? (==> <torch_hmm> set_prior_transitions <s>)
#? (==> <torch_hmm> get_states)
#? (==> <torch_hmm> set_states <s>)
#? (==> <torch_hmm> get_linear_segmentation)
#? (==> <torch_hmm> set_linear_segmentation <s>)
#? (==> <torch_hmm> get_transitions)
#? (==> <torch_hmm> set_transitions <s>)
#? (==> <torch_hmm> get_log_transitions)
#? (==> <torch_hmm> set_log_transitions <s>)
#? (==> <torch_hmm> get_dlog_transitions)
#? (==> <torch_hmm> set_dlog_transitions <s>)
#? (==> <torch_hmm> get_transitions_acc)
#? (==> <torch_hmm> set_transitions_acc <s>)
#? (==> <torch_hmm> get_log_alpha)
#? (==> <torch_hmm> set_log_alpha <s>)
#? (==> <torch_hmm> get_log_beta)
#? (==> <torch_hmm> set_log_beta <s>)
#? (==> <torch_hmm> get_arg_viterbi)
#? (==> <torch_hmm> set_arg_viterbi <s>)
#? (==> <torch_hmm> get_last_arg_viterbi)
#? (==> <torch_hmm> set_last_arg_viterbi <s>)
#? (==> <torch_hmm> get_viterbi_sequence)
#? (==> <torch_hmm> set_viterbi_sequence <s>)
#? (==> <torch_hmm> get_log_probabilities_s)
#? (==> <torch_hmm> set_log_probabilities_s <s>)
#? (new torch_hmm <flag> <n_states_> <states_> <transitions_>>
#? (==> <torch_hmm> setdataset <data_>)
#? (==> <torch_hmm> loadxfile <file>)
#? (==> <torch_hmm> savexfile <file>)
#? (==> <torch_hmm> printtransitions <real_values> <transitions_only>)
#? (==> <torch_hmm> logalpha <inputs>)
#? (==> <torch_hmm> logbeta <inputs>)
#? (==> <torch_hmm> logviterbi <inputs>)
#? (==> <torch_hmm> decode <input>)
#? (==> <torch_hmm> logprobabilities <inputs>)
#? (==> <torch_hmm> logprobability <inputs>)
#? (==> <torch_hmm> viterbilogprobability <inputs>)
#? (==> <torch_hmm> iterinitialize)
#? (==> <torch_hmm> emiterinitialize)
#? (==> <torch_hmm> emsequenceinitialize <inputs>)
#? (==> <torch_hmm> sequenceinitialize <inputs>)
#? (==> <torch_hmm> emaccposteriors <inputs> <log_posterior>)
#? (==> <torch_hmm> viterbiaccposteriors <inputs> <log_posterior>)
#? (==> <torch_hmm> emupdate)
#? (==> <torch_hmm> backward <inputs> <alpha>)
#? (==> <torch_hmm> viterbibackward <inputs> <alpha>)
#? (==> <torch_hmm> -destructor)

#? * torch_multinomial
;;.TYPE CLASS
#? (==> <torch_multinomial> get_n_values)
#? (==> <torch_multinomial> set_n_values <s>)
#? (==> <torch_multinomial> get_prior_weights)
#? (==> <torch_multinomial> set_prior_weights <s>)
#? (==> <torch_multinomial> get_log_weights)
#? (==> <torch_multinomial> set_log_weights <s>)
#? (==> <torch_multinomial> get_dlog_weights)
#? (==> <torch_multinomial> set_dlog_weights <s>)
#? (==> <torch_multinomial> get_weights_acc)
#? (==> <torch_multinomial> set_weights_acc <s>)
#? (new torch_multinomial <flag> <n_values_>>
#? (==> <torch_multinomial> reset)
#? (==> <torch_multinomial> emiterinitialize)
#? (==> <torch_multinomial> iterinitialize)
#? (==> <torch_multinomial> framelogprobability <s> <inputs>)
#? (==> <torch_multinomial> sequenceinitialize <inputs>)
#? (==> <torch_multinomial> emsequenceinitialize <inputs>)
#? (==> <torch_multinomial> frameemaccposteriors <s> <inputs> <log_posterior>)
#? (==> <torch_multinomial> emupdate)
#? (==> <torch_multinomial> framebackward <s> <f_inputs> <beta_> <f_outputs> <alpha_>)
#? (==> <torch_multinomial> frameexpectation <s> <inputs>)
#? (==> <torch_multinomial> -destructor)

#? * torch_parzendistribution
;;.TYPE CLASS
#? (==> <torch_parzendistribution> get_var)
#? (==> <torch_parzendistribution> set_var <s>)
#? (==> <torch_parzendistribution> get_data)
#? (==> <torch_parzendistribution> set_data <s>)
#? (==> <torch_parzendistribution> get_train_examples_index)
#? (==> <torch_parzendistribution> set_train_examples_index <s>)
#? (==> <torch_parzendistribution> get_n_train_examples_index)
#? (==> <torch_parzendistribution> set_n_train_examples_index <s>)
#? (==> <torch_parzendistribution> get_sum_log_var_plus_n_obs_log_2_pi)
#? (==> <torch_parzendistribution> set_sum_log_var_plus_n_obs_log_2_pi <s>)
#? (==> <torch_parzendistribution> get_minus_half_over_var)
#? (==> <torch_parzendistribution> set_minus_half_over_var <s>)
#? (new torch_parzendistribution <flag> <n_inputs_> <var_>>
#? (==> <torch_parzendistribution> setdataset <dataset_>)
#? (==> <torch_parzendistribution> setvar <var_>)
#? (==> <torch_parzendistribution> framelogprobability <s> <inputs>)
#? (==> <torch_parzendistribution> framelogprobabilityoneframe <inputs> <mean>)
#? (==> <torch_parzendistribution> emsequenceinitialize <inputs>)
#? (==> <torch_parzendistribution> sequenceinitialize <inputs>)
#? (==> <torch_parzendistribution> frameexpectation <s> <inputs>)
#? (==> <torch_parzendistribution> -destructor)

#? * torch_tablelookupdistribution
;;.TYPE CLASS
#? (==> <torch_tablelookupdistribution> get_column)
#? (==> <torch_tablelookupdistribution> set_column <s>)
#? (==> <torch_tablelookupdistribution> get_apply_log)
#? (==> <torch_tablelookupdistribution> set_apply_log <s>)
#? (==> <torch_tablelookupdistribution> get_prior)
#? (==> <torch_tablelookupdistribution> set_prior <s>)
#? (new torch_tablelookupdistribution <flag> <column_> <apply_log_> <prior_>>
#? (==> <torch_tablelookupdistribution> framelogprobability <s> <inputs>)
#? (==> <torch_tablelookupdistribution> -destructor)

#? * torch_svmclassification
;;.TYPE CLASS
#? (==> <torch_svmclassification> get_cache_size_in_megs)
#? (==> <torch_svmclassification> set_cache_size_in_megs <s>)
#? (==> <torch_svmclassification> get_cuser)
#? (==> <torch_svmclassification> set_cuser <s>)
#? (==> <torch_svmclassification> get_c_cst)
#? (==> <torch_svmclassification> set_c_cst <s>)
#? (new torch_svmclassification <flag> <kernel_> <c_> <io_sequence_array_>>
#? (==> <torch_svmclassification> setdataset <dataset_>)
#? (==> <torch_svmclassification> checksupportvectors)
#? (==> <torch_svmclassification> -destructor)

#? * torch_svmregression
;;.TYPE CLASS
#? (==> <torch_svmregression> get_cache_size_in_megs)
#? (==> <torch_svmregression> set_cache_size_in_megs <s>)
#? (==> <torch_svmregression> get_eps_regression)
#? (==> <torch_svmregression> set_eps_regression <s>)
#? (==> <torch_svmregression> get_cuser)
#? (==> <torch_svmregression> set_cuser <s>)
#? (==> <torch_svmregression> get_c_cst)
#? (==> <torch_svmregression> set_c_cst <s>)
#? (new torch_svmregression <flag> <kernel_> <c_> <io_sequence_array_>>
#? (==> <torch_svmregression> setdataset <dataset_>)
#? (==> <torch_svmregression> checksupportvectors)
#? (==> <torch_svmregression> -destructor)

#? * (dummy_level4)

;; ********************************************************



;;class MLP : public ConnectedMachine
(defclass  torch_MLP   torch_ConnectedMachine)

(defmethod  torch_MLP  get_layers ()
  
  (gptr #{ ((Torch::MLP *)$p)->layers   #} ))        ;; GradientMachine **  -> gptr

(defmethod  torch_MLP  set_layers (s )
  
  ((-gptr- "Torch::GradientMachine **") s)  
  #{ ((Torch::MLP *)$p)->layers = $s  ; #} 
  ())

(defmethod  torch_MLP  get_n_layers ()
  
  (int #{ ((Torch::MLP *)$p)->n_layers   #} ))

(defmethod  torch_MLP  set_n_layers (s )
  
  ((-int-) s)  
  #{ ((Torch::MLP *)$p)->n_layers = $s  ; #} 
  ())

(defmethod  torch_MLP  get_is_linear ()
  
  (gptr #{ ((Torch::MLP *)$p)->is_linear   #} ))        ;; bool *  -> gptr

(defmethod  torch_MLP  set_is_linear (s )
  
  ((-gptr- "bool *") s)  
  #{ ((Torch::MLP *)$p)->is_linear = $s  ; #} 
  ())

(defmethod  torch_MLP  setWeightDecay (weight_decay )
  
  ((-double-) weight_decay)  
  #{ ((Torch::MLP *)$p)->setWeightDecay($weight_decay)  ; #} 
  ())

(defmethod  torch_MLP  -destructor  ()
  
  #{ if ( $shell_flag == false )  delete  ((Torch::MLP *)$p);   #} 
  ())




;;class ClassNLLCriterion : public Criterion
(defclass  torch_ClassNLLCriterion   torch_Criterion)

(defmethod  torch_ClassNLLCriterion  get_class_format ()
  
  (gptr #{ ((Torch::ClassNLLCriterion *)$p)->class_format   #} ))        ;; ClassFormat *  -> gptr

(defmethod  torch_ClassNLLCriterion  set_class_format (s )
  
  ((-gptr- "Torch::ClassFormat *") s)  
  #{ ((Torch::ClassNLLCriterion *)$p)->class_format = $s  ; #} 
  ())

(defmethod  torch_ClassNLLCriterion  torch_ClassNLLCriterion ( flag class_format )
  ((-bool-) flag)
  
  ((-gptr- "Torch::ClassFormat *") class_format)  
  #{ if($flag == false) {
            $shell_flag = 0;
            $p = new Torch::ClassNLLCriterion($class_format); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_ClassNLLCriterion  frameForward (s  f_inputs  f_outputs )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") f_outputs)  
  #{ ((Torch::ClassNLLCriterion *)$p)->frameForward($s  ,$f_inputs  ,$f_outputs)  ; #} 
  ())

(defmethod  torch_ClassNLLCriterion  frameBackward (s  f_inputs  beta_  f_outputs  alpha_ )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") beta_)  
  ((-gptr- "double *") f_outputs)  
  ((-gptr- "double *") alpha_)  
  #{ ((Torch::ClassNLLCriterion *)$p)->frameBackward($s  ,$f_inputs  ,$beta_  ,$f_outputs  ,$alpha_)  ; #} 
  ())

(defmethod  torch_ClassNLLCriterion  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::ClassNLLCriterion *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())



;;class MSECriterion : public Criterion
(defclass  torch_MSECriterion   torch_Criterion)

(defmethod  torch_MSECriterion  get_average_frame_size ()
  
  (bool #{ ((Torch::MSECriterion *)$p)->average_frame_size   #} ))

(defmethod  torch_MSECriterion  set_average_frame_size (s )
  
  ((-bool-) s)  
  #{ ((Torch::MSECriterion *)$p)->average_frame_size = $s  ; #} 
  ())

(defmethod  torch_MSECriterion  torch_MSECriterion ( flag n_inputs_ )
  ((-bool-) flag)
  
  ((-int-) n_inputs_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::MSECriterion($n_inputs_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_MSECriterion  frameForward (s  f_inputs  f_outputs )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") f_outputs)  
  #{ ((Torch::MSECriterion *)$p)->frameForward($s  ,$f_inputs  ,$f_outputs)  ; #} 
  ())

(defmethod  torch_MSECriterion  frameBackward (s  f_inputs  beta_  f_outputs  alpha_ )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") beta_)  
  ((-gptr- "double *") f_outputs)  
  ((-gptr- "double *") alpha_)  
  #{ ((Torch::MSECriterion *)$p)->frameBackward($s  ,$f_inputs  ,$beta_  ,$f_outputs  ,$alpha_)  ; #} 
  ())

(defmethod  torch_MSECriterion  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::MSECriterion *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())





;;class MultiCriterion : public Criterion
(defclass  torch_MultiCriterion   torch_Criterion)

(defmethod  torch_MultiCriterion  get_n_criterions ()
  
  (int #{ ((Torch::MultiCriterion *)$p)->n_criterions   #} ))

(defmethod  torch_MultiCriterion  set_n_criterions (s )
  
  ((-int-) s)  
  #{ ((Torch::MultiCriterion *)$p)->n_criterions = $s  ; #} 
  ())

(defmethod  torch_MultiCriterion  get_criterions ()
  
  (gptr #{ ((Torch::MultiCriterion *)$p)->criterions   #} ))        ;; Criterion**  -> gptr

(defmethod  torch_MultiCriterion  set_criterions (s )
  
  ((-gptr- "Torch::Criterion**") s)  
  #{ ((Torch::MultiCriterion *)$p)->criterions = $s  ; #} 
  ())

(defmethod  torch_MultiCriterion  get_weights ()
  
  (gptr #{ ((Torch::MultiCriterion *)$p)->weights   #} ))        ;; real*  -> gptr

(defmethod  torch_MultiCriterion  set_weights (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::MultiCriterion *)$p)->weights = $s  ; #} 
  ())

(defmethod  torch_MultiCriterion  torch_MultiCriterion ( flag criterions_  n_criterions_  weights_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Criterion**") criterions_)  
  ((-int-) n_criterions_)  
  ((-gptr- "double *") weights_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::MultiCriterion($criterions_  ,$n_criterions_  ,$weights_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_MultiCriterion  forward (inputs )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  #{ ((Torch::MultiCriterion *)$p)->forward($inputs)  ; #} 
  ())

(defmethod  torch_MultiCriterion  backward (inputs  alpha )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  ((-gptr- "Torch::Sequence *") alpha)  
  #{ ((Torch::MultiCriterion *)$p)->backward($inputs  ,$alpha)  ; #} 
  ())

(defmethod  torch_MultiCriterion  setDataSet (data_ )
  
  ((-gptr- "Torch::DataSet *") data_)  
  #{ ((Torch::MultiCriterion *)$p)->setDataSet($data_)  ; #} 
  ())

(defmethod  torch_MultiCriterion  iterInitialize ()
  
  #{ ((Torch::MultiCriterion *)$p)->iterInitialize()  ; #} 
  ())

(defmethod  torch_MultiCriterion  reset ()
  
  #{ ((Torch::MultiCriterion *)$p)->reset()  ; #} 
  ())

(defmethod  torch_MultiCriterion  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::MultiCriterion *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())



;;class NLLCriterion : public Criterion
(defclass  torch_NLLCriterion   torch_Criterion)

(defmethod  torch_NLLCriterion  torch_NLLCriterion ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::NLLCriterion(); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_NLLCriterion  reset ()
  
  #{ ((Torch::NLLCriterion *)$p)->reset()  ; #} 
  ())

(defmethod  torch_NLLCriterion  forward (inputs )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  #{ ((Torch::NLLCriterion *)$p)->forward($inputs)  ; #} 
  ())

(defmethod  torch_NLLCriterion  backward (inputs  alpha )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  ((-gptr- "Torch::Sequence *") alpha)  
  #{ ((Torch::NLLCriterion *)$p)->backward($inputs  ,$alpha)  ; #} 
  ())

(defmethod  torch_NLLCriterion  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::NLLCriterion *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())



;;class WeightedMSECriterion : public Criterion
(defclass  torch_WeightedMSECriterion   torch_Criterion)

(defmethod  torch_WeightedMSECriterion  get_average_frame_size ()
  
  (bool #{ ((Torch::WeightedMSECriterion *)$p)->average_frame_size   #} ))

(defmethod  torch_WeightedMSECriterion  set_average_frame_size (s )
  
  ((-bool-) s)  
  #{ ((Torch::WeightedMSECriterion *)$p)->average_frame_size = $s  ; #} 
  ())

(defmethod  torch_WeightedMSECriterion  get_weights ()
  
  (gptr #{ ((Torch::WeightedMSECriterion *)$p)->weights   #} ))        ;; double *  -> gptr

(defmethod  torch_WeightedMSECriterion  set_weights (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::WeightedMSECriterion *)$p)->weights = $s  ; #} 
  ())

(defmethod  torch_WeightedMSECriterion  torch_WeightedMSECriterion ( flag data_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::DataSet *") data_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::WeightedMSECriterion($data_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_WeightedMSECriterion  torch_WeightedMSECriterion ( flag data_  weights_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "double *") weights_)  
  #{ if($flag == 0) {
            $shell_flag = 0;
            $p = new Torch::WeightedMSECriterion($data_  ,$weights_); 
     }
  #} 
  ())

(defmethod  torch_WeightedMSECriterion  setDataSet (data_ )
  
  ((-gptr- "Torch::DataSet *") data_)  
  #{ ((Torch::WeightedMSECriterion *)$p)->setDataSet($data_)  ; #} 
  ())

(defmethod  torch_WeightedMSECriterion  frameForward (s  f_inputs  f_outputs )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") f_outputs)  
  #{ ((Torch::WeightedMSECriterion *)$p)->frameForward($s  ,$f_inputs  ,$f_outputs)  ; #} 
  ())

(defmethod  torch_WeightedMSECriterion  frameBackward (s  f_inputs  beta_  f_outputs  alpha_ )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") beta_)  
  ((-gptr- "double *") f_outputs)  
  ((-gptr- "double *") alpha_)  
  #{ ((Torch::WeightedMSECriterion *)$p)->frameBackward($s  ,$f_inputs  ,$beta_  ,$f_outputs  ,$alpha_)  ; #} 
  ())

(defmethod  torch_WeightedMSECriterion  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::WeightedMSECriterion *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())





;;class DiagonalGMM : public Distribution
(defclass  torch_DiagonalGMM   torch_Distribution)

(defmethod  torch_DiagonalGMM  get_n_gaussians ()
  
  (int #{ ((Torch::DiagonalGMM *)$p)->n_gaussians   #} ))

(defmethod  torch_DiagonalGMM  set_n_gaussians (s )
  
  ((-int-) s)  
  #{ ((Torch::DiagonalGMM *)$p)->n_gaussians = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_prior_weights ()
  
  (double #{ ((Torch::DiagonalGMM *)$p)->prior_weights   #} ))

(defmethod  torch_DiagonalGMM  set_prior_weights (s )
  
  ((-double-) s)  
  #{ ((Torch::DiagonalGMM *)$p)->prior_weights = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_initial_kmeans_trainer ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->initial_kmeans_trainer   #} ))        ;; EMTrainer*  -> gptr

(defmethod  torch_DiagonalGMM  set_initial_kmeans_trainer (s )
  
  ((-gptr- "Torch::EMTrainer*") s)  
  #{ ((Torch::DiagonalGMM *)$p)->initial_kmeans_trainer = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_initial_kmeans_trainer_measurers ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->initial_kmeans_trainer_measurers   #} ))        ;; MeasurerList*  -> gptr

(defmethod  torch_DiagonalGMM  set_initial_kmeans_trainer_measurers (s )
  
  ((-gptr- "Torch::MeasurerList*") s)  
  #{ ((Torch::DiagonalGMM *)$p)->initial_kmeans_trainer_measurers = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_log_weights ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->log_weights   #} ))        ;; real*  -> gptr

(defmethod  torch_DiagonalGMM  set_log_weights (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::DiagonalGMM *)$p)->log_weights = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_means ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->means   #} ))        ;; real**  -> gptr

(defmethod  torch_DiagonalGMM  set_means (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::DiagonalGMM *)$p)->means = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_var ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->var   #} ))        ;; real**  -> gptr

(defmethod  torch_DiagonalGMM  set_var (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::DiagonalGMM *)$p)->var = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_dlog_weights ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->dlog_weights   #} ))        ;; real*  -> gptr

(defmethod  torch_DiagonalGMM  set_dlog_weights (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::DiagonalGMM *)$p)->dlog_weights = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_dmeans ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->dmeans   #} ))        ;; real**  -> gptr

(defmethod  torch_DiagonalGMM  set_dmeans (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::DiagonalGMM *)$p)->dmeans = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_dvar ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->dvar   #} ))        ;; real**  -> gptr

(defmethod  torch_DiagonalGMM  set_dvar (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::DiagonalGMM *)$p)->dvar = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_var_threshold ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->var_threshold   #} ))        ;; real*  -> gptr

(defmethod  torch_DiagonalGMM  set_var_threshold (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::DiagonalGMM *)$p)->var_threshold = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_log_probabilities_g ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->log_probabilities_g   #} ))        ;; Sequence*  -> gptr

(defmethod  torch_DiagonalGMM  set_log_probabilities_g (s )
  
  ((-gptr- "Torch::Sequence*") s)  
  #{ ((Torch::DiagonalGMM *)$p)->log_probabilities_g = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_sum_log_var_plus_n_obs_log_2_pi ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->sum_log_var_plus_n_obs_log_2_pi   #} ))        ;; real*  -> gptr

(defmethod  torch_DiagonalGMM  set_sum_log_var_plus_n_obs_log_2_pi (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::DiagonalGMM *)$p)->sum_log_var_plus_n_obs_log_2_pi = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_minus_half_over_var ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->minus_half_over_var   #} ))        ;; real**  -> gptr

(defmethod  torch_DiagonalGMM  set_minus_half_over_var (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::DiagonalGMM *)$p)->minus_half_over_var = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_means_acc ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->means_acc   #} ))        ;; real**  -> gptr

(defmethod  torch_DiagonalGMM  set_means_acc (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::DiagonalGMM *)$p)->means_acc = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_var_acc ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->var_acc   #} ))        ;; real**  -> gptr

(defmethod  torch_DiagonalGMM  set_var_acc (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::DiagonalGMM *)$p)->var_acc = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  get_weights_acc ()
  
  (gptr #{ ((Torch::DiagonalGMM *)$p)->weights_acc   #} ))        ;; real*  -> gptr

(defmethod  torch_DiagonalGMM  set_weights_acc (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::DiagonalGMM *)$p)->weights_acc = $s  ; #} 
  ())

(defmethod  torch_DiagonalGMM  torch_DiagonalGMM ( flag n_inputs_  n_gaussians_  initial_kmeans_trainer_ )
  ((-bool-) flag)
  
  ((-int-) n_inputs_)  
  ((-int-) n_gaussians_)  
  ((-gptr- "Torch::EMTrainer*") initial_kmeans_trainer_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::DiagonalGMM($n_inputs_  ,$n_gaussians_  ,$initial_kmeans_trainer_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_DiagonalGMM  reset ()
  
  #{ ((Torch::DiagonalGMM *)$p)->reset()  ; #} 
  ())

(defmethod  torch_DiagonalGMM  setDataSet (data_ )
  
  ((-gptr- "Torch::DataSet*") data_)  
  #{ ((Torch::DiagonalGMM *)$p)->setDataSet($data_)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  setVarThreshold (var_threshold_ )
  
  ((-gptr- "double *") var_threshold_)  
  #{ ((Torch::DiagonalGMM *)$p)->setVarThreshold($var_threshold_)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  display ()
  
  #{ ((Torch::DiagonalGMM *)$p)->display()  ; #} 
  ())

(defmethod  torch_DiagonalGMM  eMIterInitialize ()
  
  #{ ((Torch::DiagonalGMM *)$p)->eMIterInitialize()  ; #} 
  ())

(defmethod  torch_DiagonalGMM  iterInitialize ()
  
  #{ ((Torch::DiagonalGMM *)$p)->iterInitialize()  ; #} 
  ())

(defmethod  torch_DiagonalGMM  frameLogProbability (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  (double #{ ((Torch::DiagonalGMM *)$p)->frameLogProbability($s  ,$inputs)  #} ))

(defmethod  torch_DiagonalGMM  viterbiFrameLogProbability (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  (double #{ ((Torch::DiagonalGMM *)$p)->viterbiFrameLogProbability($s  ,$inputs)  #} ))

(defmethod  torch_DiagonalGMM  frameLogProbabilityOneGaussian (g  inputs )
  
  ((-int-) g)  
  ((-gptr- "double *") inputs)  
  (double #{ ((Torch::DiagonalGMM *)$p)->frameLogProbabilityOneGaussian($g  ,$inputs)  #} ))

(defmethod  torch_DiagonalGMM  sequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::DiagonalGMM *)$p)->sequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  eMSequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::DiagonalGMM *)$p)->eMSequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  frameEMAccPosteriors (s  inputs  log_posterior )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  ((-double-) log_posterior)  
  #{ ((Torch::DiagonalGMM *)$p)->frameEMAccPosteriors($s  ,$inputs  ,$log_posterior)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  frameViterbiAccPosteriors (s  inputs  log_posterior )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  ((-double-) log_posterior)  
  #{ ((Torch::DiagonalGMM *)$p)->frameViterbiAccPosteriors($s  ,$inputs  ,$log_posterior)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  eMUpdate ()
  
  #{ ((Torch::DiagonalGMM *)$p)->eMUpdate()  ; #} 
  ())

(defmethod  torch_DiagonalGMM  frameBackward (s  f_inputs  beta_  f_outputs  alpha_ )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") beta_)  
  ((-gptr- "double *") f_outputs)  
  ((-gptr- "double *") alpha_)  
  #{ ((Torch::DiagonalGMM *)$p)->frameBackward($s  ,$f_inputs  ,$beta_  ,$f_outputs  ,$alpha_)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  frameExpectation (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  #{ ((Torch::DiagonalGMM *)$p)->frameExpectation($s  ,$inputs)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  setNGaussians (n_gaussians_ )
  
  ((-int-) n_gaussians_)  
  #{ ((Torch::DiagonalGMM *)$p)->setNGaussians($n_gaussians_)  ; #} 
  ())

(defmethod  torch_DiagonalGMM  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::DiagonalGMM *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())




;;class HMM : public Distribution
(defclass  torch_HMM   torch_Distribution)

(defmethod  torch_HMM  get_n_states ()
  
  (int #{ ((Torch::HMM *)$p)->n_states   #} ))

(defmethod  torch_HMM  set_n_states (s )
  
  ((-int-) s)  
  #{ ((Torch::HMM *)$p)->n_states = $s  ; #} 
  ())

(defmethod  torch_HMM  get_prior_transitions ()
  
  (double #{ ((Torch::HMM *)$p)->prior_transitions   #} ))

(defmethod  torch_HMM  set_prior_transitions (s )
  
  ((-double-) s)  
  #{ ((Torch::HMM *)$p)->prior_transitions = $s  ; #} 
  ())

(defmethod  torch_HMM  get_states ()
  
  (gptr #{ ((Torch::HMM *)$p)->states   #} ))        ;; Distribution**  -> gptr

(defmethod  torch_HMM  set_states (s )
  
  ((-gptr- "Torch::Distribution**") s)  
  #{ ((Torch::HMM *)$p)->states = $s  ; #} 
  ())

(defmethod  torch_HMM  get_linear_segmentation ()
  
  (bool #{ ((Torch::HMM *)$p)->linear_segmentation   #} ))

(defmethod  torch_HMM  set_linear_segmentation (s )
  
  ((-bool-) s)  
  #{ ((Torch::HMM *)$p)->linear_segmentation = $s  ; #} 
  ())

(defmethod  torch_HMM  get_transitions ()
  
  (gptr #{ ((Torch::HMM *)$p)->transitions   #} ))        ;; real**  -> gptr

(defmethod  torch_HMM  set_transitions (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::HMM *)$p)->transitions = $s  ; #} 
  ())

(defmethod  torch_HMM  get_log_transitions ()
  
  (gptr #{ ((Torch::HMM *)$p)->log_transitions   #} ))        ;; real**  -> gptr

(defmethod  torch_HMM  set_log_transitions (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::HMM *)$p)->log_transitions = $s  ; #} 
  ())

(defmethod  torch_HMM  get_dlog_transitions ()
  
  (gptr #{ ((Torch::HMM *)$p)->dlog_transitions   #} ))        ;; real**  -> gptr

(defmethod  torch_HMM  set_dlog_transitions (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::HMM *)$p)->dlog_transitions = $s  ; #} 
  ())

(defmethod  torch_HMM  get_transitions_acc ()
  
  (gptr #{ ((Torch::HMM *)$p)->transitions_acc   #} ))        ;; real**  -> gptr

(defmethod  torch_HMM  set_transitions_acc (s )
  
  ((-gptr- "double **") s)  
  #{ ((Torch::HMM *)$p)->transitions_acc = $s  ; #} 
  ())

(defmethod  torch_HMM  get_log_alpha ()
  
  (gptr #{ ((Torch::HMM *)$p)->log_alpha   #} ))        ;; Sequence*  -> gptr

(defmethod  torch_HMM  set_log_alpha (s )
  
  ((-gptr- "Torch::Sequence*") s)  
  #{ ((Torch::HMM *)$p)->log_alpha = $s  ; #} 
  ())

(defmethod  torch_HMM  get_log_beta ()
  
  (gptr #{ ((Torch::HMM *)$p)->log_beta   #} ))        ;; Sequence*  -> gptr

(defmethod  torch_HMM  set_log_beta (s )
  
  ((-gptr- "Torch::Sequence*") s)  
  #{ ((Torch::HMM *)$p)->log_beta = $s  ; #} 
  ())

(defmethod  torch_HMM  get_arg_viterbi ()
  
  (gptr #{ ((Torch::HMM *)$p)->arg_viterbi   #} ))        ;; Sequence*  -> gptr

(defmethod  torch_HMM  set_arg_viterbi (s )
  
  ((-gptr- "Torch::Sequence*") s)  
  #{ ((Torch::HMM *)$p)->arg_viterbi = $s  ; #} 
  ())

(defmethod  torch_HMM  get_last_arg_viterbi ()
  
  (int #{ ((Torch::HMM *)$p)->last_arg_viterbi   #} ))

(defmethod  torch_HMM  set_last_arg_viterbi (s )
  
  ((-int-) s)  
  #{ ((Torch::HMM *)$p)->last_arg_viterbi = $s  ; #} 
  ())

(defmethod  torch_HMM  get_viterbi_sequence ()
  
  (gptr #{ ((Torch::HMM *)$p)->viterbi_sequence   #} ))        ;; Sequence*  -> gptr

(defmethod  torch_HMM  set_viterbi_sequence (s )
  
  ((-gptr- "Torch::Sequence*") s)  
  #{ ((Torch::HMM *)$p)->viterbi_sequence = $s  ; #} 
  ())

(defmethod  torch_HMM  get_log_probabilities_s ()
  
  (gptr #{ ((Torch::HMM *)$p)->log_probabilities_s   #} ))        ;; Sequence*  -> gptr

(defmethod  torch_HMM  set_log_probabilities_s (s )
  
  ((-gptr- "Torch::Sequence*") s)  
  #{ ((Torch::HMM *)$p)->log_probabilities_s = $s  ; #} 
  ())

(defmethod  torch_HMM  torch_HMM ( flag n_states_  states_  transitions_ )
  ((-bool-) flag)
  
  ((-int-) n_states_)  
  ((-gptr- "Torch::Distribution **") states_)  
  ((-gptr- "double **") transitions_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::HMM($n_states_  ,$states_  ,$transitions_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_HMM  setDataSet (data_ )
  
  ((-gptr- "Torch::DataSet*") data_)  
  #{ ((Torch::HMM *)$p)->setDataSet($data_)  ; #} 
  ())

(defmethod  torch_HMM  loadXFile (file )
  
  ((-gptr- "Torch::XFile *") file)  
  #{ ((Torch::HMM *)$p)->loadXFile($file)  ; #} 
  ())

(defmethod  torch_HMM  saveXFile (file )
  
  ((-gptr- "Torch::XFile *") file)  
  #{ ((Torch::HMM *)$p)->saveXFile($file)  ; #} 
  ())

(defmethod  torch_HMM  printTransitions (real_values  transitions_only )
  
  ((-bool-) real_values)  
  ((-bool-) transitions_only)  
  #{ ((Torch::HMM *)$p)->printTransitions($real_values  ,$transitions_only)  ; #} 
  ())

(defmethod  torch_HMM  logAlpha (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::HMM *)$p)->logAlpha($inputs)  ; #} 
  ())

(defmethod  torch_HMM  logBeta (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::HMM *)$p)->logBeta($inputs)  ; #} 
  ())

(defmethod  torch_HMM  logViterbi (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::HMM *)$p)->logViterbi($inputs)  ; #} 
  ())

(defmethod  torch_HMM  decode (input )
  
  ((-gptr- "Torch::Sequence*") input)  
  #{ ((Torch::HMM *)$p)->decode($input)  ; #} 
  ())

(defmethod  torch_HMM  logProbabilities (inputs )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  #{ ((Torch::HMM *)$p)->logProbabilities($inputs)  ; #} 
  ())

(defmethod  torch_HMM  logProbability (inputs )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  (double #{ ((Torch::HMM *)$p)->logProbability($inputs)  #} ))

(defmethod  torch_HMM  viterbiLogProbability (inputs )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  (double #{ ((Torch::HMM *)$p)->viterbiLogProbability($inputs)  #} ))

(defmethod  torch_HMM  iterInitialize ()
  
  #{ ((Torch::HMM *)$p)->iterInitialize()  ; #} 
  ())

(defmethod  torch_HMM  eMIterInitialize ()
  
  #{ ((Torch::HMM *)$p)->eMIterInitialize()  ; #} 
  ())

(defmethod  torch_HMM  eMSequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::HMM *)$p)->eMSequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_HMM  sequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::HMM *)$p)->sequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_HMM  eMAccPosteriors (inputs  log_posterior )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  ((-double-) log_posterior)  
  #{ ((Torch::HMM *)$p)->eMAccPosteriors($inputs  ,$log_posterior)  ; #} 
  ())

(defmethod  torch_HMM  viterbiAccPosteriors (inputs  log_posterior )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  ((-double-) log_posterior)  
  #{ ((Torch::HMM *)$p)->viterbiAccPosteriors($inputs  ,$log_posterior)  ; #} 
  ())

(defmethod  torch_HMM  eMUpdate ()
  
  #{ ((Torch::HMM *)$p)->eMUpdate()  ; #} 
  ())

(defmethod  torch_HMM  backward (inputs  alpha )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  ((-gptr- "Torch::Sequence *") alpha)  
  #{ ((Torch::HMM *)$p)->backward($inputs  ,$alpha)  ; #} 
  ())

(defmethod  torch_HMM  viterbiBackward (inputs  alpha )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  ((-gptr- "Torch::Sequence *") alpha)  
  #{ ((Torch::HMM *)$p)->viterbiBackward($inputs  ,$alpha)  ; #} 
  ())

(defmethod  torch_HMM  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::HMM *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())





;;class Multinomial : public Distribution
(defclass  torch_Multinomial   torch_Distribution)

(defmethod  torch_Multinomial  get_n_values ()
  
  (int #{ ((Torch::Multinomial *)$p)->n_values   #} ))

(defmethod  torch_Multinomial  set_n_values (s )
  
  ((-int-) s)  
  #{ ((Torch::Multinomial *)$p)->n_values = $s  ; #} 
  ())

(defmethod  torch_Multinomial  get_prior_weights ()
  
  (double #{ ((Torch::Multinomial *)$p)->prior_weights   #} ))

(defmethod  torch_Multinomial  set_prior_weights (s )
  
  ((-double-) s)  
  #{ ((Torch::Multinomial *)$p)->prior_weights = $s  ; #} 
  ())

(defmethod  torch_Multinomial  get_log_weights ()
  
  (gptr #{ ((Torch::Multinomial *)$p)->log_weights   #} ))        ;; real*  -> gptr

(defmethod  torch_Multinomial  set_log_weights (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::Multinomial *)$p)->log_weights = $s  ; #} 
  ())

(defmethod  torch_Multinomial  get_dlog_weights ()
  
  (gptr #{ ((Torch::Multinomial *)$p)->dlog_weights   #} ))        ;; real*  -> gptr

(defmethod  torch_Multinomial  set_dlog_weights (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::Multinomial *)$p)->dlog_weights = $s  ; #} 
  ())

(defmethod  torch_Multinomial  get_weights_acc ()
  
  (gptr #{ ((Torch::Multinomial *)$p)->weights_acc   #} ))        ;; real*  -> gptr

(defmethod  torch_Multinomial  set_weights_acc (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::Multinomial *)$p)->weights_acc = $s  ; #} 
  ())

(defmethod  torch_Multinomial  torch_Multinomial ( flag n_values_ )
  ((-bool-) flag)
  
  ((-int-) n_values_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::Multinomial($n_values_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_Multinomial  reset ()
  
  #{ ((Torch::Multinomial *)$p)->reset()  ; #} 
  ())

(defmethod  torch_Multinomial  eMIterInitialize ()
  
  #{ ((Torch::Multinomial *)$p)->eMIterInitialize()  ; #} 
  ())

(defmethod  torch_Multinomial  iterInitialize ()
  
  #{ ((Torch::Multinomial *)$p)->iterInitialize()  ; #} 
  ())

(defmethod  torch_Multinomial  frameLogProbability (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  (double #{ ((Torch::Multinomial *)$p)->frameLogProbability($s  ,$inputs)  #} ))

(defmethod  torch_Multinomial  sequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::Multinomial *)$p)->sequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_Multinomial  eMSequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::Multinomial *)$p)->eMSequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_Multinomial  frameEMAccPosteriors (s  inputs  log_posterior )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  ((-double-) log_posterior)  
  #{ ((Torch::Multinomial *)$p)->frameEMAccPosteriors($s  ,$inputs  ,$log_posterior)  ; #} 
  ())

(defmethod  torch_Multinomial  eMUpdate ()
  
  #{ ((Torch::Multinomial *)$p)->eMUpdate()  ; #} 
  ())

(defmethod  torch_Multinomial  frameBackward (s  f_inputs  beta_  f_outputs  alpha_ )
  
  ((-int-) s)  
  ((-gptr- "double *") f_inputs)  
  ((-gptr- "double *") beta_)  
  ((-gptr- "double *") f_outputs)  
  ((-gptr- "double *") alpha_)  
  #{ ((Torch::Multinomial *)$p)->frameBackward($s  ,$f_inputs  ,$beta_  ,$f_outputs  ,$alpha_)  ; #} 
  ())

(defmethod  torch_Multinomial  frameExpectation (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  #{ ((Torch::Multinomial *)$p)->frameExpectation($s  ,$inputs)  ; #} 
  ())

(defmethod  torch_Multinomial  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::Multinomial *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())





;;class ParzenDistribution : public Distribution
(defclass  torch_ParzenDistribution   torch_Distribution)

(defmethod  torch_ParzenDistribution  get_var ()
  
  (double #{ ((Torch::ParzenDistribution *)$p)->var   #} ))

(defmethod  torch_ParzenDistribution  set_var (s )
  
  ((-double-) s)  
  #{ ((Torch::ParzenDistribution *)$p)->var = $s  ; #} 
  ())

(defmethod  torch_ParzenDistribution  get_data ()
  
  (gptr #{ ((Torch::ParzenDistribution *)$p)->data   #} ))        ;; DataSet*  -> gptr

(defmethod  torch_ParzenDistribution  set_data (s )
  
  ((-gptr- "Torch::DataSet*") s)  
  #{ ((Torch::ParzenDistribution *)$p)->data = $s  ; #} 
  ())

(defmethod  torch_ParzenDistribution  get_train_examples_index ()
  
  (gptr #{ ((Torch::ParzenDistribution *)$p)->train_examples_index   #} ))        ;; int *  -> gptr

(defmethod  torch_ParzenDistribution  set_train_examples_index (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::ParzenDistribution *)$p)->train_examples_index = $s  ; #} 
  ())

(defmethod  torch_ParzenDistribution  get_n_train_examples_index ()
  
  (int #{ ((Torch::ParzenDistribution *)$p)->n_train_examples_index   #} ))

(defmethod  torch_ParzenDistribution  set_n_train_examples_index (s )
  
  ((-int-) s)  
  #{ ((Torch::ParzenDistribution *)$p)->n_train_examples_index = $s  ; #} 
  ())

(defmethod  torch_ParzenDistribution  get_sum_log_var_plus_n_obs_log_2_pi ()
  
  (double #{ ((Torch::ParzenDistribution *)$p)->sum_log_var_plus_n_obs_log_2_pi   #} ))

(defmethod  torch_ParzenDistribution  set_sum_log_var_plus_n_obs_log_2_pi (s )
  
  ((-double-) s)  
  #{ ((Torch::ParzenDistribution *)$p)->sum_log_var_plus_n_obs_log_2_pi = $s  ; #} 
  ())

(defmethod  torch_ParzenDistribution  get_minus_half_over_var ()
  
  (double #{ ((Torch::ParzenDistribution *)$p)->minus_half_over_var   #} ))

(defmethod  torch_ParzenDistribution  set_minus_half_over_var (s )
  
  ((-double-) s)  
  #{ ((Torch::ParzenDistribution *)$p)->minus_half_over_var = $s  ; #} 
  ())

(defmethod  torch_ParzenDistribution  torch_ParzenDistribution ( flag n_inputs_  var_ )
  ((-bool-) flag)
  
  ((-int-) n_inputs_)  
  ((-double-) var_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::ParzenDistribution($n_inputs_  ,$var_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_ParzenDistribution  setDataSet (dataset_ )
  
  ((-gptr- "Torch::DataSet*") dataset_)  
  #{ ((Torch::ParzenDistribution *)$p)->setDataSet($dataset_)  ; #} 
  ())

(defmethod  torch_ParzenDistribution  setVar (var_ )
  
  ((-double-) var_)  
  #{ ((Torch::ParzenDistribution *)$p)->setVar($var_)  ; #} 
  ())

(defmethod  torch_ParzenDistribution  frameLogProbability (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  (double #{ ((Torch::ParzenDistribution *)$p)->frameLogProbability($s  ,$inputs)  #} ))

(defmethod  torch_ParzenDistribution  frameLogProbabilityOneFrame (inputs  mean )
  
  ((-gptr- "double *") inputs)  
  ((-gptr- "double *") mean)  
  (double #{ ((Torch::ParzenDistribution *)$p)->frameLogProbabilityOneFrame($inputs  ,$mean)  #} ))

(defmethod  torch_ParzenDistribution  eMSequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::ParzenDistribution *)$p)->eMSequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_ParzenDistribution  sequenceInitialize (inputs )
  
  ((-gptr- "Torch::Sequence*") inputs)  
  #{ ((Torch::ParzenDistribution *)$p)->sequenceInitialize($inputs)  ; #} 
  ())

(defmethod  torch_ParzenDistribution  frameExpectation (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  #{ ((Torch::ParzenDistribution *)$p)->frameExpectation($s  ,$inputs)  ; #} 
  ())

(defmethod  torch_ParzenDistribution  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::ParzenDistribution *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())





;;class TableLookupDistribution : public Distribution
(defclass  torch_TableLookupDistribution   torch_Distribution)

(defmethod  torch_TableLookupDistribution  get_column ()
  
  (int #{ ((Torch::TableLookupDistribution *)$p)->column   #} ))

(defmethod  torch_TableLookupDistribution  set_column (s )
  
  ((-int-) s)  
  #{ ((Torch::TableLookupDistribution *)$p)->column = $s  ; #} 
  ())

(defmethod  torch_TableLookupDistribution  get_apply_log ()
  
  (bool #{ ((Torch::TableLookupDistribution *)$p)->apply_log   #} ))

(defmethod  torch_TableLookupDistribution  set_apply_log (s )
  
  ((-bool-) s)  
  #{ ((Torch::TableLookupDistribution *)$p)->apply_log = $s  ; #} 
  ())

(defmethod  torch_TableLookupDistribution  get_prior ()
  
  (double #{ ((Torch::TableLookupDistribution *)$p)->prior   #} ))

(defmethod  torch_TableLookupDistribution  set_prior (s )
  
  ((-double-) s)  
  #{ ((Torch::TableLookupDistribution *)$p)->prior = $s  ; #} 
  ())

(defmethod  torch_TableLookupDistribution  torch_TableLookupDistribution ( flag column_  apply_log_  prior_ )
  ((-bool-) flag)
  
  ((-int-) column_)  
  ((-bool-) apply_log_)  
  ((-double-) prior_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::TableLookupDistribution($column_  ,$apply_log_  ,$prior_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_TableLookupDistribution  frameLogProbability (s  inputs )
  
  ((-int-) s)  
  ((-gptr- "double *") inputs)  
  (double #{ ((Torch::TableLookupDistribution *)$p)->frameLogProbability($s  ,$inputs)  #} ))

(defmethod  torch_TableLookupDistribution  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::TableLookupDistribution *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())





;;class SVMClassification : public SVM
(defclass  torch_SVMClassification   torch_SVM)

(defmethod  torch_SVMClassification  get_cache_size_in_megs ()
  
  (double #{ ((Torch::SVMClassification *)$p)->cache_size_in_megs   #} ))

(defmethod  torch_SVMClassification  set_cache_size_in_megs (s )
  
  ((-double-) s)  
  #{ ((Torch::SVMClassification *)$p)->cache_size_in_megs = $s  ; #} 
  ())

(defmethod  torch_SVMClassification  get_Cuser ()
  
  (gptr #{ ((Torch::SVMClassification *)$p)->Cuser   #} ))        ;; double *  -> gptr

(defmethod  torch_SVMClassification  set_Cuser (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::SVMClassification *)$p)->Cuser = $s  ; #} 
  ())

(defmethod  torch_SVMClassification  get_C_cst ()
  
  (double #{ ((Torch::SVMClassification *)$p)->C_cst   #} ))

(defmethod  torch_SVMClassification  set_C_cst (s )
  
  ((-double-) s)  
  #{ ((Torch::SVMClassification *)$p)->C_cst = $s  ; #} 
  ())

(defmethod  torch_SVMClassification  torch_SVMClassification ( flag kernel_  C_  io_sequence_array_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Kernel *") kernel_)  
  ((-gptr- "double *") C_)  
  ((-gptr- "Torch::IOSequenceArray *") io_sequence_array_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = ::new Torch::SVMClassification($kernel_  ,$C_  ,$io_sequence_array_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_SVMClassification  setDataSet (dataset_ )
  
  ((-gptr- "Torch::DataSet *") dataset_)  
  #{ ((Torch::SVMClassification *)$p)->setDataSet($dataset_)  ; #} 
  ())

(defmethod  torch_SVMClassification  checkSupportVectors ()
  
  #{ ((Torch::SVMClassification *)$p)->checkSupportVectors()  ; #} 
  ())

(defmethod  torch_SVMClassification  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::SVMClassification *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())





;;class SVMRegression : public SVM
(defclass  torch_SVMRegression   torch_SVM)

(defmethod  torch_SVMRegression  get_cache_size_in_megs ()
  
  (double #{ ((Torch::SVMRegression *)$p)->cache_size_in_megs   #} ))

(defmethod  torch_SVMRegression  set_cache_size_in_megs (s )
  
  ((-double-) s)  
  #{ ((Torch::SVMRegression *)$p)->cache_size_in_megs = $s  ; #} 
  ())

(defmethod  torch_SVMRegression  get_eps_regression ()
  
  (double #{ ((Torch::SVMRegression *)$p)->eps_regression   #} ))

(defmethod  torch_SVMRegression  set_eps_regression (s )
  
  ((-double-) s)  
  #{ ((Torch::SVMRegression *)$p)->eps_regression = $s  ; #} 
  ())

(defmethod  torch_SVMRegression  get_Cuser ()
  
  (gptr #{ ((Torch::SVMRegression *)$p)->Cuser   #} ))        ;; double *  -> gptr

(defmethod  torch_SVMRegression  set_Cuser (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::SVMRegression *)$p)->Cuser = $s  ; #} 
  ())

(defmethod  torch_SVMRegression  get_C_cst ()
  
  (double #{ ((Torch::SVMRegression *)$p)->C_cst   #} ))

(defmethod  torch_SVMRegression  set_C_cst (s )
  
  ((-double-) s)  
  #{ ((Torch::SVMRegression *)$p)->C_cst = $s  ; #} 
  ())

(defmethod  torch_SVMRegression  torch_SVMRegression ( flag kernel_  C_  io_sequence_array_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Kernel *") kernel_)  
  ((-gptr- "double *") C_)  
  ((-gptr- "Torch::IOSequenceArray *") io_sequence_array_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::SVMRegression($kernel_  ,$C_  ,$io_sequence_array_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_SVMRegression  setDataSet (dataset_ )
  
  ((-gptr- "Torch::DataSet *") dataset_)  
  #{ ((Torch::SVMRegression *)$p)->setDataSet($dataset_)  ; #} 
  ())

(defmethod  torch_SVMRegression  checkSupportVectors ()
  
  #{ ((Torch::SVMRegression *)$p)->checkSupportVectors()  ; #} 
  ())

(defmethod  torch_SVMRegression  -destructor  ()
  
  #{ if ( $shell_flag == false )  {
             delete  ((Torch::SVMRegression *)$p);
             $p = NULL;
             $shell_flag = true; 
     }
  #} 
  ())




;; ********************************************************

(dhc-make-with-c++ () (list torch-libtorch) 
  dummy_level4
  (torch_mlp  -destructor  setweightdecay  set_is_linear  get_is_linear  set_n_layers  get_n_layers  set_layers  get_layers)
  (torch_classnllcriterion  -destructor  framebackward  frameforward  torch_classnllcriterion  set_class_format  get_class_format)
  (torch_msecriterion  -destructor  framebackward  frameforward  torch_msecriterion  set_average_frame_size  get_average_frame_size)
  (torch_multicriterion  -destructor  reset  iterinitialize  setdataset  backward  forward  torch_multicriterion  set_weights  get_weights  set_criterions  get_criterions  set_n_criterions  get_n_criterions)
  (torch_nllcriterion  -destructor  backward  forward  reset  torch_nllcriterion)
;; overloaded constructor : torch_weightedmsecriterion 
  (torch_weightedmsecriterion  -destructor  framebackward  frameforward  setdataset   torch_weightedmsecriterion  set_weights  get_weights  set_average_frame_size  get_average_frame_size)
  (torch_diagonalgmm  -destructor  setngaussians  frameexpectation  framebackward  emupdate  frameviterbiaccposteriors  frameemaccposteriors  emsequenceinitialize  sequenceinitialize  framelogprobabilityonegaussian  viterbiframelogprobability  framelogprobability  iterinitialize  emiterinitialize  display  setvarthreshold  setdataset  reset  torch_diagonalgmm  set_weights_acc  get_weights_acc  set_var_acc  get_var_acc  set_means_acc  get_means_acc  set_minus_half_over_var  get_minus_half_over_var  set_sum_log_var_plus_n_obs_log_2_pi  get_sum_log_var_plus_n_obs_log_2_pi  set_log_probabilities_g  get_log_probabilities_g  set_var_threshold  get_var_threshold  set_dvar  get_dvar  set_dmeans  get_dmeans  set_dlog_weights  get_dlog_weights  set_var  get_var  set_means  get_means  set_log_weights  get_log_weights  set_initial_kmeans_trainer_measurers  get_initial_kmeans_trainer_measurers  set_initial_kmeans_trainer  get_initial_kmeans_trainer  set_prior_weights  get_prior_weights  set_n_gaussians  get_n_gaussians)
  (torch_hmm  -destructor  viterbibackward  backward  emupdate  viterbiaccposteriors  emaccposteriors  sequenceinitialize  emsequenceinitialize  emiterinitialize  iterinitialize  viterbilogprobability  logprobability  logprobabilities  decode  logviterbi  logbeta  logalpha  printtransitions  savexfile  loadxfile  setdataset  torch_hmm  set_log_probabilities_s  get_log_probabilities_s  set_viterbi_sequence  get_viterbi_sequence  set_last_arg_viterbi  get_last_arg_viterbi  set_arg_viterbi  get_arg_viterbi  set_log_beta  get_log_beta  set_log_alpha  get_log_alpha  set_transitions_acc  get_transitions_acc  set_dlog_transitions  get_dlog_transitions  set_log_transitions  get_log_transitions  set_transitions  get_transitions  set_linear_segmentation  get_linear_segmentation  set_states  get_states  set_prior_transitions  get_prior_transitions  set_n_states  get_n_states)
  (torch_multinomial  -destructor  frameexpectation  framebackward  emupdate  frameemaccposteriors  emsequenceinitialize  sequenceinitialize  framelogprobability  iterinitialize  emiterinitialize  reset  torch_multinomial  set_weights_acc  get_weights_acc  set_dlog_weights  get_dlog_weights  set_log_weights  get_log_weights  set_prior_weights  get_prior_weights  set_n_values  get_n_values)
  (torch_parzendistribution  -destructor  frameexpectation  sequenceinitialize  emsequenceinitialize  framelogprobabilityoneframe  framelogprobability  setvar  setdataset  torch_parzendistribution  set_minus_half_over_var  get_minus_half_over_var  set_sum_log_var_plus_n_obs_log_2_pi  get_sum_log_var_plus_n_obs_log_2_pi  set_n_train_examples_index  get_n_train_examples_index  set_train_examples_index  get_train_examples_index  set_data  get_data  set_var  get_var)
  (torch_tablelookupdistribution  -destructor  framelogprobability  torch_tablelookupdistribution  set_prior  get_prior  set_apply_log  get_apply_log  set_column  get_column)
  (torch_svmclassification  -destructor  checksupportvectors  setdataset  torch_svmclassification  set_c_cst  get_c_cst  set_cuser  get_cuser  set_cache_size_in_megs  get_cache_size_in_megs)
  (torch_svmregression  -destructor  checksupportvectors  setdataset  torch_svmregression  set_c_cst  get_c_cst  set_cuser  get_cuser  set_eps_regression  get_eps_regression  set_cache_size_in_megs  get_cache_size_in_megs)
)
