;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 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/level1")


#? *** level2

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

#? * torch_bagging
;;.TYPE CLASS
#? (==> <torch_bagging> get_w_machine)
#? (==> <torch_bagging> set_w_machine <s>)
#? (==> <torch_bagging> get_n_trainers)
#? (==> <torch_bagging> set_n_trainers <s>)
#? (==> <torch_bagging> get_unselected_examples)
#? (==> <torch_bagging> set_unselected_examples <s>)
#? (==> <torch_bagging> get_selected_examples)
#? (==> <torch_bagging> set_selected_examples <s>)
#? (==> <torch_bagging> get_n_unselected_examples)
#? (==> <torch_bagging> set_n_unselected_examples <s>)
#? (==> <torch_bagging> get_is_selected_examples)
#? (==> <torch_bagging> set_is_selected_examples <s>)
#? (new torch_bagging <flag> <w_machine>>
#? (==> <torch_bagging> bootstrapdata <selected> <is_selected> <n_examples>)
#? (==> <torch_bagging> train <data> <measurers>)
#? (==> <torch_bagging> -destructor)

#? * torch_gradientmachine
;;.TYPE CLASS
#? (==> <torch_gradientmachine> get_partial_backprop)
#? (==> <torch_gradientmachine> set_partial_backprop <s>)
#? (==> <torch_gradientmachine> get_n_inputs)
#? (==> <torch_gradientmachine> set_n_inputs <s>)
#? (==> <torch_gradientmachine> get_n_outputs)
#? (==> <torch_gradientmachine> set_n_outputs <s>)
#? (==> <torch_gradientmachine> get_params)
#? (==> <torch_gradientmachine> set_params <s>)
#? (==> <torch_gradientmachine> get_der_params)
#? (==> <torch_gradientmachine> set_der_params <s>)
#? (==> <torch_gradientmachine> get_beta)
#? (==> <torch_gradientmachine> set_beta <s>)
#? (new torch_gradientmachine <flag> <n_inputs_> <n_outputs_> <n_params_>>
#? (==> <torch_gradientmachine> iterinitialize)
#? (==> <torch_gradientmachine> forward <inputs>)
#? (==> <torch_gradientmachine> backward <inputs> <alpha>)
#? (==> <torch_gradientmachine> setpartialbackprop <flag>)
#? (==> <torch_gradientmachine> frameforward <s> <f_inputs> <f_outputs>)
#? (==> <torch_gradientmachine> framebackward <s> <f_inputs> <beta_> <f_outputs> <alpha_>)
#? (==> <torch_gradientmachine> loadxfile <file>)
#? (==> <torch_gradientmachine> savexfile <file>)
#? (==> <torch_gradientmachine> -destructor)

#? * torch_bayesclassifier
;;.TYPE CLASS
#? (==> <torch_bayesclassifier> get_bayesmachine)
#? (==> <torch_bayesclassifier> set_bayesmachine <s>)
#? (==> <torch_bayesclassifier> get_n_classes)
#? (==> <torch_bayesclassifier> set_n_classes <s>)
#? (==> <torch_bayesclassifier> get_classes)
#? (==> <torch_bayesclassifier> set_classes <s>)
#? (==> <torch_bayesclassifier> get_classes_n)
#? (==> <torch_bayesclassifier> set_classes_n <s>)
#? (new torch_bayesclassifier <flag> <s>>
#? (==> <torch_bayesclassifier> -destructor)
#? (==> <torch_bayesclassifier> train <data> <measurers>)

#? * torch_bayesclassifiermachine
;;.TYPE CLASS
#? (==> <torch_bayesclassifiermachine> get_n_trainers)
#? (==> <torch_bayesclassifiermachine> set_n_trainers <s>)
#? (==> <torch_bayesclassifiermachine> get_n_outputs)
#? (==> <torch_bayesclassifiermachine> set_n_outputs <s>)
#? (==> <torch_bayesclassifiermachine> get_trainers)
#? (==> <torch_bayesclassifiermachine> set_trainers <s>)
#? (==> <torch_bayesclassifiermachine> get_log_priors)
#? (==> <torch_bayesclassifiermachine> set_log_priors <s>)
#? (==> <torch_bayesclassifiermachine> get_log_probabilities)
#? (==> <torch_bayesclassifiermachine> set_log_probabilities <s>)
#? (==> <torch_bayesclassifiermachine> get_allocated_log_priors)
#? (==> <torch_bayesclassifiermachine> set_allocated_log_priors <s>)
#? (==> <torch_bayesclassifiermachine> get_class_format)
#? (==> <torch_bayesclassifiermachine> set_class_format <s>)
#? (==> <torch_bayesclassifiermachine> get_trainers_measurers)
#? (==> <torch_bayesclassifiermachine> set_trainers_measurers <s>)
#? (new torch_bayesclassifiermachine <flag> <s> <n_trainers_> <trainers_measurers_> <class_format_> <log_priors_>>
#? (==> <torch_bayesclassifiermachine> -destructor)
#? (==> <torch_bayesclassifiermachine> forward <inputs>)
#? (==> <torch_bayesclassifiermachine> reset)
#? (==> <torch_bayesclassifiermachine> loadxfile <s>)
#? (==> <torch_bayesclassifiermachine> savexfile <s>)

#? * torch_boosting
;;.TYPE CLASS
#? (==> <torch_boosting> get_w_machine)
#? (==> <torch_boosting> set_w_machine <s>)
#? (==> <torch_boosting> get_class_format)
#? (==> <torch_boosting> set_class_format <s>)
#? (==> <torch_boosting> get_n_trainers)
#? (==> <torch_boosting> set_n_trainers <s>)
#? (==> <torch_boosting> get_weights)
#? (==> <torch_boosting> set_weights <s>)
#? (new torch_boosting <flag> <w_machine_> <class_format_>>
#? (==> <torch_boosting> train <data> <measurers>)
#? (==> <torch_boosting> -destructor)

#? * torch_boostingmeasurer
;;.TYPE CLASS
#? (==> <torch_boostingmeasurer> get_inputs)
#? (==> <torch_boostingmeasurer> set_inputs <s>)
#? (==> <torch_boostingmeasurer> get_weights)
#? (==> <torch_boostingmeasurer> set_weights <s>)
#? (==> <torch_boostingmeasurer> get_beta)
#? (==> <torch_boostingmeasurer> set_beta <s>)
#? (==> <torch_boostingmeasurer> get_status)
#? (==> <torch_boostingmeasurer> set_status <s>)
#? (==> <torch_boostingmeasurer> get_internal_error)
#? (==> <torch_boostingmeasurer> set_internal_error <s>)
#? (==> <torch_boostingmeasurer> get_current_example)
#? (==> <torch_boostingmeasurer> set_current_example <s>)
#? (==> <torch_boostingmeasurer> get_class_format)
#? (==> <torch_boostingmeasurer> set_class_format <s>)
#? (new torch_boostingmeasurer <flag> <class_format_> <file_>>
#? (==> <torch_boostingmeasurer> setdataset <data_>)
#? (==> <torch_boostingmeasurer> setweights <weights_>)
#? (==> <torch_boostingmeasurer> setinputs <inputs_>)
#? (==> <torch_boostingmeasurer> init_)
#? (==> <torch_boostingmeasurer> reset)
#? (==> <torch_boostingmeasurer> measureexample)
#? (==> <torch_boostingmeasurer> measureiteration)
#? (==> <torch_boostingmeasurer> -destructor)

#? * torch_classformatdataset
;;.TYPE CLASS
#? (==> <torch_classformatdataset> get_data)
#? (==> <torch_classformatdataset> set_data <s>)
#? (==> <torch_classformatdataset> get_class_labels)
#? (==> <torch_classformatdataset> set_class_labels <s>)
#? (new torch_classformatdataset <flag> <data_> <class_labels_>>
#? (==> <torch_classformatdataset> getnumberofframes <t_> <n_input_frames_> <n_target_frames_>)
#? (==> <torch_classformatdataset> setrealexample <s> <set_inputs> <set_targets>)
#? (==> <torch_classformatdataset> preprocess <pre_processing>)
#? (==> <torch_classformatdataset> pushexample)
#? (==> <torch_classformatdataset> popexample)
#? (==> <torch_classformatdataset> -destructor)

#? * torch_classmeasurer
;;.TYPE CLASS
#? (==> <torch_classmeasurer> get_internal_error)
#? (==> <torch_classmeasurer> set_internal_error <s>)
#? (==> <torch_classmeasurer> get_confusion)
#? (==> <torch_classmeasurer> set_confusion <s>)
#? (==> <torch_classmeasurer> get_inputs)
#? (==> <torch_classmeasurer> set_inputs <s>)
#? (==> <torch_classmeasurer> get_class_format)
#? (==> <torch_classmeasurer> set_class_format <s>)
#? (==> <torch_classmeasurer> get_calc_confusion)
#? (==> <torch_classmeasurer> set_calc_confusion <s>)
#? (==> <torch_classmeasurer> get_calc_confusion_at_each_iter)
#? (==> <torch_classmeasurer> set_calc_confusion_at_each_iter <s>)
#? (==> <torch_classmeasurer> get_n_classes)
#? (==> <torch_classmeasurer> set_n_classes <s>)
#? (new torch_classmeasurer <flag> <inputs_> <data_> <class_format_> <file_> <calc_confusion_> <calc_confusion_at_each_iter_>>
#? (==> <torch_classmeasurer> printconfusionmatrix)
#? (==> <torch_classmeasurer> reset)
#? (==> <torch_classmeasurer> measureexample)
#? (==> <torch_classmeasurer> measureiteration)
#? (==> <torch_classmeasurer> measureend)
#? (==> <torch_classmeasurer> init_)
#? (==> <torch_classmeasurer> reset_)
#? (==> <torch_classmeasurer> -destructor)

#? * torch_classnllmeasurer
;;.TYPE CLASS
#? (==> <torch_classnllmeasurer> get_class_format)
#? (==> <torch_classnllmeasurer> set_class_format <s>)
#? (==> <torch_classnllmeasurer> get_average_examples)
#? (==> <torch_classnllmeasurer> set_average_examples <s>)
#? (==> <torch_classnllmeasurer> get_average_frames)
#? (==> <torch_classnllmeasurer> set_average_frames <s>)
#? (==> <torch_classnllmeasurer> get_internal_error)
#? (==> <torch_classnllmeasurer> set_internal_error <s>)
#? (==> <torch_classnllmeasurer> get_inputs)
#? (==> <torch_classnllmeasurer> set_inputs <s>)
#? (new torch_classnllmeasurer <flag> <inputs_> <data_> <class_format_> <file_>>
#? (==> <torch_classnllmeasurer> reset)
#? (==> <torch_classnllmeasurer> measureexample)
#? (==> <torch_classnllmeasurer> measureiteration)
#? (==> <torch_classnllmeasurer> -destructor)

#? * torch_diskdataset
;;.TYPE CLASS
#? (==> <torch_diskdataset> get_pre_processes)
#? (==> <torch_diskdataset> set_pre_processes <s>)
#? (==> <torch_diskdataset> get_io_inputs)
#? (==> <torch_diskdataset> set_io_inputs <s>)
#? (==> <torch_diskdataset> get_io_targets)
#? (==> <torch_diskdataset> set_io_targets <s>)
#? (new torch_diskdataset <flag>>
#? (==> <torch_diskdataset> init <io_inputs_> <io_targets_>)
#? (==> <torch_diskdataset> getnumberofframes <s> <n_input_frames> <n_target_frames>)
#? (==> <torch_diskdataset> preprocess <pre_processing>)
#? (==> <torch_diskdataset> setrealexample <s> <set_inputs> <set_targets>)
#? (==> <torch_diskdataset> pushexample)
#? (==> <torch_diskdataset> popexample)
#? (==> <torch_diskdataset> -destructor)

#? * torch_diskxfile
;;.TYPE CLASS
#? (==> <torch_diskxfile> get_file)
#? (==> <torch_diskxfile> set_file <s>)
#? (==> <torch_diskxfile> get_is_opened)
#? (==> <torch_diskxfile> set_is_opened <s>)
#? (==> <torch_diskxfile> get_its_a_pipe)
#? (==> <torch_diskxfile> set_its_a_pipe <s>)
#? (new torch_diskxfile <flag> <file_name> <open_flags>>
#? (==> <torch_diskxfile> islittleendianprocessor)
#? (==> <torch_diskxfile> isbigendianprocessor)
#? (==> <torch_diskxfile> isnativemode)
#? (==> <torch_diskxfile> setnativemode)
#? (==> <torch_diskxfile> setlittleendianmode)
#? (==> <torch_diskxfile> setbigendianmode)
#? (==> <torch_diskxfile> read <ptr> <block_size> <n_blocks>)
#? (==> <torch_diskxfile> write <ptr> <block_size> <n_blocks>)
#? (==> <torch_diskxfile> eof)
#? (==> <torch_diskxfile> flush)
#? (==> <torch_diskxfile> seek <offset> <whence>)
#? (==> <torch_diskxfile> tell)
#? (==> <torch_diskxfile> rewind)
#? (==> <torch_diskxfile> scanf <format> <ptr>)
#? (==> <torch_diskxfile> gets <dest> <size_>)
#? (==> <torch_diskxfile> -destructor)

#? * torch_emtrainer
;;.TYPE CLASS
#? (==> <torch_emtrainer> get_distribution)
#? (==> <torch_emtrainer> set_distribution <s>)
#? (==> <torch_emtrainer> get_end_accuracy)
#? (==> <torch_emtrainer> set_end_accuracy <s>)
#? (==> <torch_emtrainer> get_max_iter)
#? (==> <torch_emtrainer> set_max_iter <s>)
#? (==> <torch_emtrainer> get_viterbi)
#? (==> <torch_emtrainer> set_viterbi <s>)
#? (new torch_emtrainer <flag> <distribution_>>
#? (==> <torch_emtrainer> train <data> <measurers>)
#? (==> <torch_emtrainer> test <measurers>)
#? (==> <torch_emtrainer> decode <measurers>)
#? (==> <torch_emtrainer> -destructor)

#? * torch_exampleframeselectordataset
;;.TYPE CLASS
#? (==> <torch_exampleframeselectordataset> get_data)
#? (==> <torch_exampleframeselectordataset> set_data <s>)
#? (==> <torch_exampleframeselectordataset> get_n_selected_input_frames)
#? (==> <torch_exampleframeselectordataset> set_n_selected_input_frames <s>)
#? (==> <torch_exampleframeselectordataset> get_n_selected_target_frames)
#? (==> <torch_exampleframeselectordataset> set_n_selected_target_frames <s>)
#? (==> <torch_exampleframeselectordataset> get_input_frames_indices)
#? (==> <torch_exampleframeselectordataset> set_input_frames_indices <s>)
#? (==> <torch_exampleframeselectordataset> get_target_frames_indices)
#? (==> <torch_exampleframeselectordataset> set_target_frames_indices <s>)
#? (new torch_exampleframeselectordataset <flag> <data_>>
#? (==> <torch_exampleframeselectordataset> addexample <s> <inputs_start_indices_> <n_inputs_frames_> <targets_start_indices_> <n_targets_frames_>)
#? (==> <torch_exampleframeselectordataset> removeexample <s>)
#? (==> <torch_exampleframeselectordataset> getnumberofframes <t_> <n_input_frames_> <n_target_frames_>)
#? (==> <torch_exampleframeselectordataset> setrealexample <s> <set_inputs> <set_targets>)
#? (==> <torch_exampleframeselectordataset> pushexample)
#? (==> <torch_exampleframeselectordataset> popexample)
#? (==> <torch_exampleframeselectordataset> preprocess <pre_processing>)
#? (==> <torch_exampleframeselectordataset> -destructor)

#? * torch_frameselectordataset
;;.TYPE CLASS
#? (==> <torch_frameselectordataset> get_data)
#? (==> <torch_frameselectordataset> set_data <s>)
#? (==> <torch_frameselectordataset> get_n_selected_input_frames)
#? (==> <torch_frameselectordataset> set_n_selected_input_frames <s>)
#? (==> <torch_frameselectordataset> get_n_selected_target_frames)
#? (==> <torch_frameselectordataset> set_n_selected_target_frames <s>)
#? (==> <torch_frameselectordataset> get_input_frames_indices)
#? (==> <torch_frameselectordataset> set_input_frames_indices <s>)
#? (==> <torch_frameselectordataset> get_target_frames_indices)
#? (==> <torch_frameselectordataset> set_target_frames_indices <s>)
#? (new torch_frameselectordataset <flag> <data_>>
#? (==> <torch_frameselectordataset> selectinputframes <t_> <frames_indices_> <n_frames_>)
#? (==> <torch_frameselectordataset> selecttargetframes <t_> <frames_indices_> <n_frames_>)
#? (==> <torch_frameselectordataset> unselectinputframes <t_>)
#? (==> <torch_frameselectordataset> unselecttargetframes <t_>)
#? (==> <torch_frameselectordataset> preprocess <pre_processing>)
#? (==> <torch_frameselectordataset> getnumberofframes <t_> <n_input_frames_> <n_target_frames_>)
#? (==> <torch_frameselectordataset> setrealexample <s> <set_inputs> <set_targets>)
#? (==> <torch_frameselectordataset> pushexample)
#? (==> <torch_frameselectordataset> popexample)
#? (==> <torch_frameselectordataset> -destructor)

#? * torch_ioascii
;;.TYPE CLASS
#? (==> <torch_ioascii> get_one_file_is_one_sequence)
#? (==> <torch_ioascii> set_one_file_is_one_sequence <s>)
#? (==> <torch_ioascii> get_n_total_frames)
#? (==> <torch_ioascii> set_n_total_frames <s>)
#? (==> <torch_ioascii> get_filename)
#? (==> <torch_ioascii> set_filename <s>)
#? (==> <torch_ioascii> get_max_load)
#? (==> <torch_ioascii> set_max_load <s>)
#? (new torch_ioascii <flag> <filename_> <one_file_is_one_sequence_> <max_load_>>
#? (==> <torch_ioascii> savesequence <file> <sequence>)
#? (==> <torch_ioascii> getsequence <s> <sequence>)
#? (==> <torch_ioascii> getnumberofframes <s>)
#? (==> <torch_ioascii> gettotalnumberofframes)
#? (==> <torch_ioascii> -destructor)

#? * torch_iobin
;;.TYPE CLASS
#? (==> <torch_iobin> get_one_file_is_one_sequence)
#? (==> <torch_iobin> set_one_file_is_one_sequence <s>)
#? (==> <torch_iobin> get_n_total_frames)
#? (==> <torch_iobin> set_n_total_frames <s>)
#? (==> <torch_iobin> get_filename)
#? (==> <torch_iobin> set_filename <s>)
#? (==> <torch_iobin> get_max_load)
#? (==> <torch_iobin> set_max_load <s>)
#? (==> <torch_iobin> get_is_sequential)
#? (==> <torch_iobin> set_is_sequential <s>)
#? (new torch_iobin <flag> <filename_> <one_file_is_one_sequence_> <max_load_> <is_sequential>>
#? (==> <torch_iobin> savesequence <file> <sequence>)
#? (==> <torch_iobin> getsequence <s> <sequence>)
#? (==> <torch_iobin> getnumberofframes <s>)
#? (==> <torch_iobin> gettotalnumberofframes)
#? (==> <torch_iobin> -destructor)

#? * torch_iobufferize
;;.TYPE CLASS
#? (==> <torch_iobufferize> get_io_torch)
#? (==> <torch_iobufferize> set_io_torch <s>)
#? (==> <torch_iobufferize> get_bufferized_sequence)
#? (==> <torch_iobufferize> set_bufferized_sequence <s>)
#? (==> <torch_iobufferize> get_bufferized_sequence_index)
#? (==> <torch_iobufferize> set_bufferized_sequence_index <s>)
#? (new torch_iobufferize <flag> <io_torch_>>
#? (==> <torch_iobufferize> bufferizesequence <s>)
#? (==> <torch_iobufferize> getsequence <s> <sequence>)
#? (==> <torch_iobufferize> getnumberofframes <s>)
#? (==> <torch_iobufferize> gettotalnumberofframes)
#? (==> <torch_iobufferize> -destructor)

#? * torch_iohtk
;;.TYPE CLASS
#? (==> <torch_iohtk> get_one_file_is_one_sequence)
#? (==> <torch_iohtk> set_one_file_is_one_sequence <s>)
#? (==> <torch_iohtk> get_n_total_frames)
#? (==> <torch_iohtk> set_n_total_frames <s>)
#? (==> <torch_iohtk> get_filename)
#? (==> <torch_iohtk> set_filename <s>)
#? (==> <torch_iohtk> get_max_load)
#? (==> <torch_iohtk> set_max_load <s>)
#? (==> <torch_iohtk> get_is_sequential)
#? (==> <torch_iohtk> set_is_sequential <s>)
#? (==> <torch_iohtk> get_header)
#? (==> <torch_iohtk> set_header <s>)
#? (new torch_iohtk <flag> <filename_> <one_file_is_one_sequence_> <max_load_> <is_sequential_>>
#? (==> <torch_iohtk> savesequence <file> <sequence> <header_>)
#? (==> <torch_iohtk> getsequence <s> <sequence>)
#? (==> <torch_iohtk> getnumberofframes <s>)
#? (==> <torch_iohtk> gettotalnumberofframes)
#? (==> <torch_iohtk> -destructor)
#? (==> <torch_iohtk> parmkind2str <kind> <buf>)
#? (==> <torch_iohtk> str2parmkind <str>)
#? (==> <torch_iohtk> baseparmkind <kind>)
#? (==> <torch_iohtk> hasenergy <kind>)
#? (==> <torch_iohtk> hasdelta <kind>)
#? (==> <torch_iohtk> hasaccs <kind>)
#? (==> <torch_iohtk> hasnulle <kind>)
#? (==> <torch_iohtk> hascompx <kind>)
#? (==> <torch_iohtk> hascrcc <kind>)
#? (==> <torch_iohtk> haszerom <kind>)
#? (==> <torch_iohtk> haszeroc <kind>)
#? (==> <torch_iohtk> hasvq <kind>)

#? * torch_iohtktarget
;;.TYPE CLASS
#? (==> <torch_iohtktarget> get_one_file_is_one_sequence)
#? (==> <torch_iohtktarget> set_one_file_is_one_sequence <s>)
#? (==> <torch_iohtktarget> get_n_total_frames)
#? (==> <torch_iohtktarget> set_n_total_frames <s>)
#? (==> <torch_iohtktarget> get_filename)
#? (==> <torch_iohtktarget> set_filename <s>)
#? (==> <torch_iohtktarget> get_max_load)
#? (==> <torch_iohtktarget> set_max_load <s>)
#? (==> <torch_iohtktarget> get_n_per_frame)
#? (==> <torch_iohtktarget> set_n_per_frame <s>)
#? (==> <torch_iohtktarget> get_dictionary)
#? (==> <torch_iohtktarget> set_dictionary <s>)
#? (==> <torch_iohtktarget> get_words)
#? (==> <torch_iohtktarget> set_words <s>)
#? (new torch_iohtktarget <flag> <filename_> <dictionary_> <n_per_frame_> <words>>
#? (==> <torch_iohtktarget> savesequence <file> <sequence> <dictionary_> <n_per_frame_> <words_>)
#? (==> <torch_iohtktarget> getsequence <s> <sequence>)
#? (==> <torch_iohtktarget> getnumberofframes <s>)
#? (==> <torch_iohtktarget> gettotalnumberofframes)
#? (==> <torch_iohtktarget> -destructor)

#? * torch_iomulti
;;.TYPE CLASS
#? (==> <torch_iomulti> get_io_files)
#? (==> <torch_iomulti> set_io_files <s>)
#? (==> <torch_iomulti> get_n_files)
#? (==> <torch_iomulti> set_n_files <s>)
#? (==> <torch_iomulti> get_indices)
#? (==> <torch_iomulti> set_indices <s>)
#? (==> <torch_iomulti> get_offsets)
#? (==> <torch_iomulti> set_offsets <s>)
#? (new torch_iomulti <flag> <io_files_> <n_files_>>
#? (==> <torch_iomulti> getsequence <s> <sequence>)
#? (==> <torch_iomulti> getnumberofframes <s>)
#? (==> <torch_iomulti> gettotalnumberofframes)
#? (==> <torch_iomulti> -destructor)

#? * torch_iosub
;;.TYPE CLASS
#? (==> <torch_iosub> get_io_torch)
#? (==> <torch_iosub> set_io_torch <s>)
#? (==> <torch_iosub> get_offset)
#? (==> <torch_iosub> set_offset <s>)
#? (new torch_iosub <flag> <io_torch_> <offset_> <frame_size_>>
#? (==> <torch_iosub> getsequence <s> <sequence>)
#? (==> <torch_iosub> getnumberofframes <s>)
#? (==> <torch_iosub> gettotalnumberofframes)
#? (==> <torch_iosub> -destructor)

#? * torch_dotkernel
;;.TYPE CLASS
#? (==> <torch_dotkernel> get_s)
#? (==> <torch_dotkernel> set_s <s>)
#? (new torch_dotkernel <flag> <s_>>
#? (==> <torch_dotkernel> eval <x> <y>)
#? (==> <torch_dotkernel> -destructor)

#? * torch_polynomialkernel
;;.TYPE CLASS
#? (==> <torch_polynomialkernel> get_d)
#? (==> <torch_polynomialkernel> set_d <s>)
#? (==> <torch_polynomialkernel> get_s)
#? (==> <torch_polynomialkernel> set_s <s>)
#? (==> <torch_polynomialkernel> get_r)
#? (==> <torch_polynomialkernel> set_r <s>)
#? (new torch_polynomialkernel <flag> <degree> <s_> <r_>>
#? (==> <torch_polynomialkernel> eval <x> <y>)
#? (==> <torch_polynomialkernel> -destructor)

#? * torch_gaussiankernel
;;.TYPE CLASS
#? (==> <torch_gaussiankernel> get_g)
#? (==> <torch_gaussiankernel> set_g <s>)
#? (new torch_gaussiankernel <flag> <g_>>
#? (==> <torch_gaussiankernel> eval <x> <y>)
#? (==> <torch_gaussiankernel> -destructor)

#? * torch_sigmoidkernel
;;.TYPE CLASS
#? (==> <torch_sigmoidkernel> get_s)
#? (==> <torch_sigmoidkernel> set_s <s>)
#? (==> <torch_sigmoidkernel> get_r)
#? (==> <torch_sigmoidkernel> set_r <s>)
#? (new torch_sigmoidkernel <flag> <s_> <r_>>
#? (==> <torch_sigmoidkernel> eval <x> <y>)
#? (==> <torch_sigmoidkernel> -destructor)

#? * torch_knn
;;.TYPE CLASS
#? (==> <torch_knn> get_k)
#? (==> <torch_knn> set_k <s>)
#? (==> <torch_knn> get_distances)
#? (==> <torch_knn> set_distances <s>)
#? (==> <torch_knn> get_indices)
#? (==> <torch_knn> set_indices <s>)
#? (==> <torch_knn> get_data)
#? (==> <torch_knn> set_data <s>)
#? (==> <torch_knn> get_n_outputs)
#? (==> <torch_knn> set_n_outputs <s>)
#? (==> <torch_knn> get_real_examples)
#? (==> <torch_knn> set_real_examples <s>)
#? (==> <torch_knn> get_n_real_examples)
#? (==> <torch_knn> set_n_real_examples <s>)
#? (new torch_knn <flag> <n_outputs_> <k_>>
#? (==> <torch_knn> forward <inputs>)
#? (==> <torch_knn> setdataset <dataset_>)
#? (==> <torch_knn> setk <k_>)
#? (==> <torch_knn> -destructor)

#? * torch_meanvarnorm
;;.TYPE CLASS
#? (==> <torch_meanvarnorm> get_n_inputs)
#? (==> <torch_meanvarnorm> set_n_inputs <s>)
#? (==> <torch_meanvarnorm> get_n_targets)
#? (==> <torch_meanvarnorm> set_n_targets <s>)
#? (==> <torch_meanvarnorm> get_inputs_mean)
#? (==> <torch_meanvarnorm> set_inputs_mean <s>)
#? (==> <torch_meanvarnorm> get_targets_mean)
#? (==> <torch_meanvarnorm> set_targets_mean <s>)
#? (==> <torch_meanvarnorm> get_inputs_stdv)
#? (==> <torch_meanvarnorm> set_inputs_stdv <s>)
#? (==> <torch_meanvarnorm> get_targets_stdv)
#? (==> <torch_meanvarnorm> set_targets_stdv <s>)
#? (new torch_meanvarnorm <flag> <data> <norm_inputs> <norm_targets>>
#? (==> <torch_meanvarnorm> preprocessinputs <inputs>)
#? (==> <torch_meanvarnorm> preprocesstargets <targets>)
#? (==> <torch_meanvarnorm> loadxfile <file>)
#? (==> <torch_meanvarnorm> savexfile <file>)
#? (==> <torch_meanvarnorm> -destructor)

#? * torch_memorydataset
;;.TYPE CLASS
#? (==> <torch_memorydataset> get_inputs_array)
#? (==> <torch_memorydataset> set_inputs_array <s>)
#? (==> <torch_memorydataset> get_targets_array)
#? (==> <torch_memorydataset> set_targets_array <s>)
#? (new torch_memorydataset <flag>>
#? (==> <torch_memorydataset> init <io_inputs> <io_outputs>)
#? (==> <torch_memorydataset> setinputs <inputs_> <n_sequences_>)
#? (==> <torch_memorydataset> settargets <targets_> <n_sequences_>)
#? (==> <torch_memorydataset> getnumberofframes <s> <n_input_frames_> <n_target_frames_>)
#? (==> <torch_memorydataset> preprocess <pre_processing>)
#? (==> <torch_memorydataset> setrealexample <s> <set_inputs> <set_targets>)
#? (==> <torch_memorydataset> pushexample)
#? (==> <torch_memorydataset> popexample)
#? (==> <torch_memorydataset> -destructor)

#? * torch_memoryxfile
;;.TYPE CLASS
#? (==> <torch_memoryxfile> get_memory)
#? (==> <torch_memoryxfile> set_memory <s>)
#? (==> <torch_memoryxfile> get_position)
#? (==> <torch_memoryxfile> set_position <s>)
#? (==> <torch_memoryxfile> get_size)
#? (==> <torch_memoryxfile> set_size <s>)
#? (==> <torch_memoryxfile> get_total_size)
#? (==> <torch_memoryxfile> set_total_size <s>)
#? (==> <torch_memoryxfile> get_buffer_size)
#? (==> <torch_memoryxfile> set_buffer_size <s>)
#? (==> <torch_memoryxfile> get_internal_memory_node_index)
#? (==> <torch_memoryxfile> set_internal_memory_node_index <s>)
#? (==> <torch_memoryxfile> get_internal_position_in_the_node)
#? (==> <torch_memoryxfile> set_internal_position_in_the_node <s>)
#? (==> <torch_memoryxfile> get_buffer_format)
#? (==> <torch_memoryxfile> set_buffer_format <s>)
#? (==> <torch_memoryxfile> get_buffer_format_size)
#? (==> <torch_memoryxfile> set_buffer_format_size <s>)
#? (new torch_memoryxfile <flag> <buffer_format_size_>>
#? (==> <torch_memoryxfile> concat)
#? (==> <torch_memoryxfile> read <ptr> <block_size> <n_blocks>)
#? (==> <torch_memoryxfile> write <ptr> <block_size> <n_blocks>)
#? (==> <torch_memoryxfile> eof)
#? (==> <torch_memoryxfile> flush)
#? (==> <torch_memoryxfile> seek <offset> <whence>)
#? (==> <torch_memoryxfile> tell)
#? (==> <torch_memoryxfile> rewind)
#? (==> <torch_memoryxfile> scanf <format> <ptr>)
#? (==> <torch_memoryxfile> gets <dest> <size_>)
#? (==> <torch_memoryxfile> -destructor)

#? * torch_msemeasurer
;;.TYPE CLASS
#? (==> <torch_msemeasurer> get_average_examples)
#? (==> <torch_msemeasurer> set_average_examples <s>)
#? (==> <torch_msemeasurer> get_average_frame_size)
#? (==> <torch_msemeasurer> set_average_frame_size <s>)
#? (==> <torch_msemeasurer> get_average_frames)
#? (==> <torch_msemeasurer> set_average_frames <s>)
#? (==> <torch_msemeasurer> get_internal_error)
#? (==> <torch_msemeasurer> set_internal_error <s>)
#? (==> <torch_msemeasurer> get_inputs)
#? (==> <torch_msemeasurer> set_inputs <s>)
#? (new torch_msemeasurer <flag> <inputs_> <data_> <file_>>
#? (==> <torch_msemeasurer> reset)
#? (==> <torch_msemeasurer> measureexample)
#? (==> <torch_msemeasurer> measureiteration)
#? (==> <torch_msemeasurer> -destructor)

#? * torch_multiclassformat
;;.TYPE CLASS
#? (==> <torch_multiclassformat> get_tabclasses)
#? (==> <torch_multiclassformat> set_tabclasses <s>)
#? (new torch_multiclassformat <flag> <data>>
#? (==> <torch_multiclassformat> getclass <vector>)
#? (==> <torch_multiclassformat> getoutputsize)
#? (==> <torch_multiclassformat> fromonehot <outputs> <one_hot_outputs>)
#? (==> <torch_multiclassformat> toonehot <outputs> <one_hot_outputs>)
#? (==> <torch_multiclassformat> -destructor)

#? * torch_nllmeasurer
;;.TYPE CLASS
#? (==> <torch_nllmeasurer> get_average_examples)
#? (==> <torch_nllmeasurer> set_average_examples <s>)
#? (==> <torch_nllmeasurer> get_average_frames)
#? (==> <torch_nllmeasurer> set_average_frames <s>)
#? (==> <torch_nllmeasurer> get_internal_error)
#? (==> <torch_nllmeasurer> set_internal_error <s>)
#? (==> <torch_nllmeasurer> get_inputs)
#? (==> <torch_nllmeasurer> set_inputs <s>)
#? (new torch_nllmeasurer <flag> <inputs_> <data_> <file_>>
#? (==> <torch_nllmeasurer> reset)
#? (==> <torch_nllmeasurer> measureexample)
#? (==> <torch_nllmeasurer> measureiteration)
#? (==> <torch_nllmeasurer> -destructor)

#? * torch_nptrainer
;;.TYPE CLASS
#? (new torch_nptrainer <flag> <machine_>>
#? (==> <torch_nptrainer> train <s> <measurers>)
#? (==> <torch_nptrainer> -destructor)

#? * torch_nullxfile
;;.TYPE CLASS
#? (new torch_nullxfile <flag>>
#? (==> <torch_nullxfile> read <ptr> <block_size> <n_blocks>)
#? (==> <torch_nullxfile> write <ptr> <block_size> <n_blocks>)
#? (==> <torch_nullxfile> eof)
#? (==> <torch_nullxfile> flush)
#? (==> <torch_nullxfile> seek <offset> <whence>)
#? (==> <torch_nullxfile> tell)
#? (==> <torch_nullxfile> rewind)
#? (==> <torch_nullxfile> scanf <format> <ptr>)
#? (==> <torch_nullxfile> gets <dest> <size_>)
#? (==> <torch_nullxfile> -destructor)

#? * torch_onehotclassformat
;;.TYPE CLASS
#? (==> <torch_onehotclassformat> get_class_labels_buffer)
#? (==> <torch_onehotclassformat> set_class_labels_buffer <s>)
#? (new torch_onehotclassformat <flag> <data>>
#? (==> <torch_onehotclassformat> getclass <target>)
#? (==> <torch_onehotclassformat> getoutputsize)
#? (==> <torch_onehotclassformat> fromonehot <outputs> <one_hot_outputs>)
#? (==> <torch_onehotclassformat> toonehot <outputs> <one_hot_outputs>)
#? (==> <torch_onehotclassformat> -destructor)

#? * torch_outputmeasurer
;;.TYPE CLASS
#? (==> <torch_outputmeasurer> get_sequences)
#? (==> <torch_outputmeasurer> set_sequences <s>)
#? (==> <torch_outputmeasurer> get_total_frame_size)
#? (==> <torch_outputmeasurer> set_total_frame_size <s>)
#? (new torch_outputmeasurer <flag> <data_> <file_>>
#? (==> <torch_outputmeasurer> addsequence <sequence>)
#? (==> <torch_outputmeasurer> measureexample)
#? (==> <torch_outputmeasurer> -destructor)

#? * torch_parzenmachine
;;.TYPE CLASS
#? (==> <torch_parzenmachine> get_var)
#? (==> <torch_parzenmachine> set_var <s>)
#? (==> <torch_parzenmachine> get_data)
#? (==> <torch_parzenmachine> set_data <s>)
#? (==> <torch_parzenmachine> get_real_examples)
#? (==> <torch_parzenmachine> set_real_examples <s>)
#? (==> <torch_parzenmachine> get_n_real_examples)
#? (==> <torch_parzenmachine> set_n_real_examples <s>)
#? (==> <torch_parzenmachine> get_denominator)
#? (==> <torch_parzenmachine> set_denominator <s>)
#? (==> <torch_parzenmachine> get_n_outputs)
#? (==> <torch_parzenmachine> set_n_outputs <s>)
#? (==> <torch_parzenmachine> get_n_inputs)
#? (==> <torch_parzenmachine> set_n_inputs <s>)
#? (new torch_parzenmachine <flag> <n_inputs_> <n_outputs_> <var_>>
#? (==> <torch_parzenmachine> forward <inputs>)
#? (==> <torch_parzenmachine> setdataset <dataset_>)
#? (==> <torch_parzenmachine> setvar <var_>)
#? (==> <torch_parzenmachine> -destructor)

#? * torch_qcmachine
;;.TYPE CLASS
#? (==> <torch_qcmachine> get_cup)
#? (==> <torch_qcmachine> set_cup <s>)
#? (==> <torch_qcmachine> get_cdown)
#? (==> <torch_qcmachine> set_cdown <s>)
#? (==> <torch_qcmachine> get_bound_eps)
#? (==> <torch_qcmachine> set_bound_eps <s>)
#? (==> <torch_qcmachine> get_n_alpha)
#? (==> <torch_qcmachine> set_n_alpha <s>)
#? (==> <torch_qcmachine> get_alpha)
#? (==> <torch_qcmachine> set_alpha <s>)
#? (==> <torch_qcmachine> get_grad)
#? (==> <torch_qcmachine> set_grad <s>)
#? (==> <torch_qcmachine> get_y)
#? (==> <torch_qcmachine> set_y <s>)
#? (==> <torch_qcmachine> get_cache)
#? (==> <torch_qcmachine> set_cache <s>)
#? (new torch_qcmachine <flag>>
#? (==> <torch_qcmachine> reinit <n_alpha_>)
#? (==> <torch_qcmachine> -destructor)

#? * torch_qctrainer
;;.TYPE CLASS
#? (==> <torch_qctrainer> get_qcmachine)
#? (==> <torch_qctrainer> set_qcmachine <s>)
#? (==> <torch_qctrainer> get_cache)
#? (==> <torch_qctrainer> set_cache <s>)
#? (==> <torch_qctrainer> get_n_unshrink)
#? (==> <torch_qctrainer> set_n_unshrink <s>)
#? (==> <torch_qctrainer> get_n_max_unshrink)
#? (==> <torch_qctrainer> set_n_max_unshrink <s>)
#? (==> <torch_qctrainer> get_k_xi)
#? (==> <torch_qctrainer> set_k_xi <s>)
#? (==> <torch_qctrainer> get_k_xj)
#? (==> <torch_qctrainer> set_k_xj <s>)
#? (==> <torch_qctrainer> get_old_alpha_xi)
#? (==> <torch_qctrainer> set_old_alpha_xi <s>)
#? (==> <torch_qctrainer> get_old_alpha_xj)
#? (==> <torch_qctrainer> set_old_alpha_xj <s>)
#? (==> <torch_qctrainer> get_current_error)
#? (==> <torch_qctrainer> set_current_error <s>)
#? (==> <torch_qctrainer> get_active_var_new)
#? (==> <torch_qctrainer> set_active_var_new <s>)
#? (==> <torch_qctrainer> get_n_active_var_new)
#? (==> <torch_qctrainer> set_n_active_var_new <s>)
#? (==> <torch_qctrainer> get_n_alpha)
#? (==> <torch_qctrainer> set_n_alpha <s>)
#? (==> <torch_qctrainer> get_deja_shrink)
#? (==> <torch_qctrainer> set_deja_shrink <s>)
#? (==> <torch_qctrainer> get_unshrink_mode)
#? (==> <torch_qctrainer> set_unshrink_mode <s>)
#? (==> <torch_qctrainer> get_y)
#? (==> <torch_qctrainer> set_y <s>)
#? (==> <torch_qctrainer> get_alpha)
#? (==> <torch_qctrainer> set_alpha <s>)
#? (==> <torch_qctrainer> get_grad)
#? (==> <torch_qctrainer> set_grad <s>)
#? (==> <torch_qctrainer> get_eps_shrink)
#? (==> <torch_qctrainer> set_eps_shrink <s>)
#? (==> <torch_qctrainer> get_end_eps)
#? (==> <torch_qctrainer> set_end_eps <s>)
#? (==> <torch_qctrainer> get_bound_eps)
#? (==> <torch_qctrainer> set_bound_eps <s>)
#? (==> <torch_qctrainer> get_n_active_var)
#? (==> <torch_qctrainer> set_n_active_var <s>)
#? (==> <torch_qctrainer> get_active_var)
#? (==> <torch_qctrainer> set_active_var <s>)
#? (==> <torch_qctrainer> get_not_at_bound_at_iter)
#? (==> <torch_qctrainer> set_not_at_bound_at_iter <s>)
#? (==> <torch_qctrainer> get_iter)
#? (==> <torch_qctrainer> set_iter <s>)
#? (==> <torch_qctrainer> get_n_iter_min_to_shrink)
#? (==> <torch_qctrainer> set_n_iter_min_to_shrink <s>)
#? (==> <torch_qctrainer> get_n_iter_message)
#? (==> <torch_qctrainer> set_n_iter_message <s>)
#? (==> <torch_qctrainer> get_status_alpha)
#? (==> <torch_qctrainer> set_status_alpha <s>)
#? (==> <torch_qctrainer> get_cup)
#? (==> <torch_qctrainer> set_cup <s>)
#? (==> <torch_qctrainer> get_cdown)
#? (==> <torch_qctrainer> set_cdown <s>)
#? (new torch_qctrainer <flag> <qcmachine_>>
#? (==> <torch_qctrainer> train <data> <measurers>)
#? (==> <torch_qctrainer> preparetolaunch)
#? (==> <torch_qctrainer> atomiseall)
#? (==> <torch_qctrainer> bcompute)
#? (==> <torch_qctrainer> selectvariables <i> <j>)
#? (==> <torch_qctrainer> checkshrinking <bmin> <bmax>)
#? (==> <torch_qctrainer> shrink)
#? (==> <torch_qctrainer> unshrink)
#? (==> <torch_qctrainer> analyticsolve <xi> <xj>)
#? (==> <torch_qctrainer> updatestatus <i>)
#? (==> <torch_qctrainer> isnotup <i>)
#? (==> <torch_qctrainer> isnotdown <i>)
#? (==> <torch_qctrainer> -destructor)

#? * torch_saturationmeasurer
;;.TYPE CLASS
#? (==> <torch_saturationmeasurer> get_derivatives_sum)
#? (==> <torch_saturationmeasurer> set_derivatives_sum <s>)
#? (==> <torch_saturationmeasurer> get_outputs_sum)
#? (==> <torch_saturationmeasurer> set_outputs_sum <s>)
#? (==> <torch_saturationmeasurer> get_n_sum_out)
#? (==> <torch_saturationmeasurer> set_n_sum_out <s>)
#? (==> <torch_saturationmeasurer> get_n_sum_der)
#? (==> <torch_saturationmeasurer> set_n_sum_der <s>)
#? (==> <torch_saturationmeasurer> get_machine)
#? (==> <torch_saturationmeasurer> set_machine <s>)
#? (new torch_saturationmeasurer <flag> <machine_> <data_> <file_>>
#? (==> <torch_saturationmeasurer> reset)
#? (==> <torch_saturationmeasurer> reset_)
#? (==> <torch_saturationmeasurer> measureexample)
#? (==> <torch_saturationmeasurer> measureiteration)
#? (==> <torch_saturationmeasurer> -destructor)

#? * torch_stochasticgradient
;;.TYPE CLASS
#? (==> <torch_stochasticgradient> get_criterion)
#? (==> <torch_stochasticgradient> set_criterion <s>)
#? (==> <torch_stochasticgradient> get_learning_rate)
#? (==> <torch_stochasticgradient> set_learning_rate <s>)
#? (==> <torch_stochasticgradient> get_learning_rate_decay)
#? (==> <torch_stochasticgradient> set_learning_rate_decay <s>)
#? (==> <torch_stochasticgradient> get_end_accuracy)
#? (==> <torch_stochasticgradient> set_end_accuracy <s>)
#? (==> <torch_stochasticgradient> get_max_iter)
#? (==> <torch_stochasticgradient> set_max_iter <s>)
#? (==> <torch_stochasticgradient> get_do_shuffle)
#? (==> <torch_stochasticgradient> set_do_shuffle <s>)
#? (new torch_stochasticgradient <flag> <machine_> <criterion_>>
#? (==> <torch_stochasticgradient> train <data> <measurers>)
#? (==> <torch_stochasticgradient> -destructor)

#? * torch_svmcache
;;.TYPE CLASS
#? (==> <torch_svmcache> get_n_alpha)
#? (==> <torch_svmcache> set_n_alpha <s>)
#? (==> <torch_svmcache> get_n_cache_entries)
#? (==> <torch_svmcache> set_n_cache_entries <s>)
#? (==> <torch_svmcache> get_cache_size_in_megs)
#? (==> <torch_svmcache> set_cache_size_in_megs <s>)
#? (==> <torch_svmcache> get_memory_cache)
#? (==> <torch_svmcache> set_memory_cache <s>)
#? (==> <torch_svmcache> get_cached)
#? (==> <torch_svmcache> set_cached <s>)
#? (==> <torch_svmcache> get_list_index)
#? (==> <torch_svmcache> set_list_index <s>)
#? (==> <torch_svmcache> get_kernel)
#? (==> <torch_svmcache> set_kernel <s>)
#? (==> <torch_svmcache> get_n_active_var)
#? (==> <torch_svmcache> set_n_active_var <s>)
#? (==> <torch_svmcache> get_active_var)
#? (==> <torch_svmcache> set_active_var <s>)
#? (==> <torch_svmcache> get_temp_allocator)
#? (==> <torch_svmcache> set_temp_allocator <s>)
#? (new torch_svmcache <flag> <n_alpha_> <kernel_> <cache_size_in_megs_>>
#? (==> <torch_svmcache> allocate)
#? (==> <torch_svmcache> clear)
#? (==> <torch_svmcache> destroy)
#? (==> <torch_svmcache> setactivevariables <active_var_> <n_active_var_>)
#? (==> <torch_svmcache> adresscache <index>)
#? (==> <torch_svmcache> -destructor)

#? * torch_timemeasurer
;;.TYPE CLASS
#? (==> <torch_timemeasurer> get_timer)
#? (==> <torch_timemeasurer> set_timer <s>)
#? (new torch_timemeasurer <flag> <data_> <file_>>
#? (==> <torch_timemeasurer> reset)
#? (==> <torch_timemeasurer> measureiteration)
#? (==> <torch_timemeasurer> measureend)
#? (==> <torch_timemeasurer> -destructor)

#? * torch_twoclassformat
;;.TYPE CLASS
#? (==> <torch_twoclassformat> get_tabclasses <i>)
#? (==> <torch_twoclassformat> set_tabclasses <s> <i>)
#? (new torch_twoclassformat <flag> <data>>
#? (==> <torch_twoclassformat> getclass <vector>)
#? (==> <torch_twoclassformat> getoutputsize)
#? (==> <torch_twoclassformat> fromonehot <outputs> <one_hot_outputs>)
#? (==> <torch_twoclassformat> toonehot <outputs> <one_hot_outputs>)
#? (==> <torch_twoclassformat> -destructor)

#? * torch_weightedsummachine
;;.TYPE CLASS
#? (==> <torch_weightedsummachine> get_n_outputs)
#? (==> <torch_weightedsummachine> set_n_outputs <s>)
#? (==> <torch_weightedsummachine> get_trainers)
#? (==> <torch_weightedsummachine> set_trainers <s>)
#? (==> <torch_weightedsummachine> get_trainers_measurers)
#? (==> <torch_weightedsummachine> set_trainers_measurers <s>)
#? (==> <torch_weightedsummachine> get_n_trainers)
#? (==> <torch_weightedsummachine> set_n_trainers <s>)
#? (==> <torch_weightedsummachine> get_n_trainers_trained)
#? (==> <torch_weightedsummachine> set_n_trainers_trained <s>)
#? (==> <torch_weightedsummachine> get_weights)
#? (==> <torch_weightedsummachine> set_weights <s>)
#? (==> <torch_weightedsummachine> get_weights_is_allocated)
#? (==> <torch_weightedsummachine> set_weights_is_allocated <s>)
#? (new torch_weightedsummachine <flag> <trainer_> <n_trainers_> <trainers_measurers> <weights_>>
#? (==> <torch_weightedsummachine> forward <inputs>)
#? (==> <torch_weightedsummachine> reset)
#? (==> <torch_weightedsummachine> loadxfile <file>)
#? (==> <torch_weightedsummachine> savexfile <file>)
#? (==> <torch_weightedsummachine> -destructor)

#? * (dummy_level2)

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


;;class Bagging : public Trainer
(defclass  torch_Bagging   torch_Trainer)

(defmethod  torch_Bagging  get_w_machine ()  
  
  (gptr #{ ((Torch::Bagging *)$p)->w_machine   #} ))        ;; WeightedSumMachine*  -> gptr

(defmethod  torch_Bagging  set_w_machine (s )
  
  ((-gptr- "Torch::WeightedSumMachine *") s)  
  #{ ((Torch::Bagging *)$p)->w_machine = $s  ; #} 
  ())

(defmethod  torch_Bagging  get_n_trainers ()
  
  (int #{ ((Torch::Bagging *)$p)->n_trainers   #} ))

(defmethod  torch_Bagging  set_n_trainers (s )
  
  ((-int-) s)  
  #{ ((Torch::Bagging *)$p)->n_trainers = $s  ; #} 
  ())

(defmethod  torch_Bagging  get_unselected_examples ()
  
  (gptr #{ ((Torch::Bagging *)$p)->unselected_examples   #} ))        ;; int**  -> gptr

(defmethod  torch_Bagging  set_unselected_examples (s )
  
  ((-gptr- "int**") s)  
  #{ ((Torch::Bagging *)$p)->unselected_examples = $s  ; #} 
  ())

(defmethod  torch_Bagging  get_selected_examples ()
  
  (gptr #{ ((Torch::Bagging *)$p)->selected_examples   #} ))        ;; int**  -> gptr

(defmethod  torch_Bagging  set_selected_examples (s )
  
  ((-gptr- "int**") s)  
  #{ ((Torch::Bagging *)$p)->selected_examples = $s  ; #} 
  ())

(defmethod  torch_Bagging  get_n_unselected_examples ()
  
  (gptr #{ ((Torch::Bagging *)$p)->n_unselected_examples   #} ))        ;; int*  -> gptr

(defmethod  torch_Bagging  set_n_unselected_examples (s )
  
  ((-gptr- "int*") s)  
  #{ ((Torch::Bagging *)$p)->n_unselected_examples = $s  ; #} 
  ())

(defmethod  torch_Bagging  get_is_selected_examples ()
  
  (gptr #{ ((Torch::Bagging *)$p)->is_selected_examples   #} ))        ;; int*  -> gptr

(defmethod  torch_Bagging  set_is_selected_examples (s )
  
  ((-gptr- "int*") s)  
  #{ ((Torch::Bagging *)$p)->is_selected_examples = $s  ; #} 
  ())

(defmethod  torch_Bagging  torch_Bagging ( flag w_machine )
  ((-bool-) flag)
  
  ((-gptr- "Torch::WeightedSumMachine *") w_machine)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::Bagging($w_machine); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_Bagging  bootstrapData (selected  is_selected  n_examples )
  
  ((-gptr- "int*") selected)  
  ((-gptr- "int*") is_selected)  
  ((-int-) n_examples)  
  #{ ((Torch::Bagging *)$p)->bootstrapData($selected  ,$is_selected  ,$n_examples)  ; #} 
  ())

(defmethod  torch_Bagging  train (data  measurers )
  
  ((-gptr- "Torch::DataSet *") data)  
  ((-gptr- "Torch::MeasurerList*") measurers)  
  #{ ((Torch::Bagging *)$p)->train($data  ,$measurers)  ; #} 
  ())

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







;;class GradientMachine : public Machine
(defclass  torch_GradientMachine   torch_Machine)

(defmethod  torch_GradientMachine  get_partial_backprop ()
  
  (bool #{ ((Torch::GradientMachine *)$p)->partial_backprop   #} ))

(defmethod  torch_GradientMachine  set_partial_backprop (s )
  
  ((-bool-) s)  
  #{ ((Torch::GradientMachine *)$p)->partial_backprop = $s  ; #} 
  ())

(defmethod  torch_GradientMachine  get_n_inputs ()
  
  (int #{ ((Torch::GradientMachine *)$p)->n_inputs   #} ))

(defmethod  torch_GradientMachine  set_n_inputs (s )
  
  ((-int-) s)  
  #{ ((Torch::GradientMachine *)$p)->n_inputs = $s  ; #} 
  ())

(defmethod  torch_GradientMachine  get_n_outputs ()
  
  (int #{ ((Torch::GradientMachine *)$p)->n_outputs   #} ))

(defmethod  torch_GradientMachine  set_n_outputs (s )
  
  ((-int-) s)  
  #{ ((Torch::GradientMachine *)$p)->n_outputs = $s  ; #} 
  ())

(defmethod  torch_GradientMachine  get_params ()
  
  (gptr #{ ((Torch::GradientMachine *)$p)->params   #} ))        ;; Parameters *  -> gptr

(defmethod  torch_GradientMachine  set_params (s )
  
  ((-gptr- "Torch::Parameters *") s)  
  #{ ((Torch::GradientMachine *)$p)->params = $s  ; #} 
  ())

(defmethod  torch_GradientMachine  get_der_params ()
  
  (gptr #{ ((Torch::GradientMachine *)$p)->der_params   #} ))        ;; Parameters *  -> gptr

(defmethod  torch_GradientMachine  set_der_params (s )
  
  ((-gptr- "Torch::Parameters *") s)  
  #{ ((Torch::GradientMachine *)$p)->der_params = $s  ; #} 
  ())

(defmethod  torch_GradientMachine  get_beta ()
  
  (gptr #{ ((Torch::GradientMachine *)$p)->beta   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_GradientMachine  set_beta (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::GradientMachine *)$p)->beta = $s  ; #} 
  ())

(defmethod  torch_GradientMachine  torch_GradientMachine ( flag n_inputs_  n_outputs_  n_params_ )
  ((-bool-) flag)
  
  ((-int-) n_inputs_)  
  ((-int-) n_outputs_)  
  ((-int-) n_params_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::GradientMachine($n_inputs_  ,$n_outputs_  ,$n_params_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_GradientMachine  iterInitialize ()
  
  #{ ((Torch::GradientMachine *)$p)->iterInitialize()  ; #} 
  ())

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

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

(defmethod  torch_GradientMachine  setPartialBackprop (flag )
  
  ((-bool-) flag)  
  #{ ((Torch::GradientMachine *)$p)->setPartialBackprop($flag)  ; #} 
  ())

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

(defmethod  torch_GradientMachine  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::GradientMachine *)$p)->frameBackward($s  ,$f_inputs  ,$beta_  ,$f_outputs  ,$alpha_)  ; #} 
  ())

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

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

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








;;class BayesClassifier : public Trainer
(defclass  torch_BayesClassifier   torch_Trainer)

(defmethod  torch_BayesClassifier  get_bayesmachine ()
  
  (gptr #{ ((Torch::BayesClassifier *)$p)->bayesmachine   #} ))        ;; BayesClassifierMachine*  -> gptr

(defmethod  torch_BayesClassifier  set_bayesmachine (s )
  
  ((-gptr- "Torch::BayesClassifierMachine*") s)  
  #{ ((Torch::BayesClassifier *)$p)->bayesmachine = $s  ; #} 
  ())

(defmethod  torch_BayesClassifier  get_n_classes ()
  
  (int #{ ((Torch::BayesClassifier *)$p)->n_classes   #} ))

(defmethod  torch_BayesClassifier  set_n_classes (s )
  
  ((-int-) s)  
  #{ ((Torch::BayesClassifier *)$p)->n_classes = $s  ; #} 
  ())

(defmethod  torch_BayesClassifier  get_classes ()
  
  (gptr #{ ((Torch::BayesClassifier *)$p)->classes   #} ))        ;; int**  -> gptr

(defmethod  torch_BayesClassifier  set_classes (s )
  
  ((-gptr- "int**") s)  
  #{ ((Torch::BayesClassifier *)$p)->classes = $s  ; #} 
  ())

(defmethod  torch_BayesClassifier  get_classes_n ()
  
  (gptr #{ ((Torch::BayesClassifier *)$p)->classes_n   #} ))        ;; int*  -> gptr

(defmethod  torch_BayesClassifier  set_classes_n (s )
  
  ((-gptr- "int*") s)  
  #{ ((Torch::BayesClassifier *)$p)->classes_n = $s  ; #} 
  ())

(defmethod  torch_BayesClassifier  torch_BayesClassifier ( flag s )
  ((-bool-) flag)
  
  ((-gptr- "Torch::BayesClassifierMachine*") s)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::BayesClassifier($s ); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

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

(defmethod  torch_BayesClassifier  train (data  measurers )
  
  ((-gptr- "Torch::DataSet *") data)  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::BayesClassifier *)$p)->train($data  ,$measurers)  ; #} 
  ())



;;class BayesClassifierMachine : public Machine
(defclass  torch_BayesClassifierMachine   torch_Machine)

(defmethod  torch_BayesClassifierMachine  get_n_trainers ()
  
  (int #{ ((Torch::BayesClassifierMachine *)$p)->n_trainers   #} ))

(defmethod  torch_BayesClassifierMachine  set_n_trainers (s )
  
  ((-int-) s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->n_trainers = $s  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  get_n_outputs ()
  
  (int #{ ((Torch::BayesClassifierMachine *)$p)->n_outputs   #} ))

(defmethod  torch_BayesClassifierMachine  set_n_outputs (s )
  
  ((-int-) s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->n_outputs = $s  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  get_trainers ()
  
  (gptr #{ ((Torch::BayesClassifierMachine *)$p)->trainers   #} ))        ;; Trainer**  -> gptr

(defmethod  torch_BayesClassifierMachine  set_trainers (s )
  
  ((-gptr- "Torch::EMTrainer**") s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->trainers = $s  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  get_log_priors ()
  
  (gptr #{ ((Torch::BayesClassifierMachine *)$p)->log_priors   #} ))        ;; real*  -> gptr

(defmethod  torch_BayesClassifierMachine  set_log_priors (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->log_priors = $s  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  get_log_probabilities ()
  
  (gptr #{ ((Torch::BayesClassifierMachine *)$p)->log_probabilities   #} ))        ;; Sequence*  -> gptr

(defmethod  torch_BayesClassifierMachine  set_log_probabilities (s )
  
  ((-gptr- "Torch::Sequence*") s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->log_probabilities = $s  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  get_allocated_log_priors ()
  
  (bool #{ ((Torch::BayesClassifierMachine *)$p)->allocated_log_priors   #} ))

(defmethod  torch_BayesClassifierMachine  set_allocated_log_priors (s )
  
  ((-bool-) s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->allocated_log_priors = $s  ; #} 
  ())

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

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

(defmethod  torch_BayesClassifierMachine  get_trainers_measurers ()
  
  (gptr #{ ((Torch::BayesClassifierMachine *)$p)->trainers_measurers   #} ))        ;; MeasurerList**  -> gptr

(defmethod  torch_BayesClassifierMachine  set_trainers_measurers (s )
  
  ((-gptr- "Torch::MeasurerList**") s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->trainers_measurers = $s  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  torch_BayesClassifierMachine ( flag s n_trainers_ trainers_measurers_ class_format_  log_priors_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::EMTrainer**") s)  
  ((-int-) n_trainers_)  
  ((-gptr- "Torch::MeasurerList**") trainers_measurers_)  
  ((-gptr- "Torch::ClassFormat*") class_format_)  
  ((-gptr- "double *") log_priors_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::BayesClassifierMachine($s  ,$n_trainers_  ,$trainers_measurers_  ,$class_format_  ,$log_priors_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

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

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

(defmethod  torch_BayesClassifierMachine  reset ()
  
  #{ ((Torch::BayesClassifierMachine *)$p)->reset()  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  loadXFile (s )
  
  ((-gptr- "Torch::XFile*") s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->loadXFile($s )  ; #} 
  ())

(defmethod  torch_BayesClassifierMachine  saveXFile (s )
  
  ((-gptr- "Torch::XFile*") s)  
  #{ ((Torch::BayesClassifierMachine *)$p)->saveXFile($s )  ; #} 
  ())



;;class Boosting : public Trainer
(defclass  torch_Boosting   torch_Trainer)

(defmethod  torch_Boosting  get_w_machine ()
  
  (gptr #{ ((Torch::Boosting *)$p)->w_machine   #} ))        ;; WeightedSumMachine *  -> gptr

(defmethod  torch_Boosting  set_w_machine (s )
  
  ((-gptr- "Torch::WeightedSumMachine *") s)  
  #{ ((Torch::Boosting *)$p)->w_machine = $s  ; #} 
  ())

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

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

(defmethod  torch_Boosting  get_n_trainers ()
  
  (int #{ ((Torch::Boosting *)$p)->n_trainers   #} ))

(defmethod  torch_Boosting  set_n_trainers (s )
  
  ((-int-) s)  
  #{ ((Torch::Boosting *)$p)->n_trainers = $s  ; #} 
  ())

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

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

(defmethod  torch_Boosting  torch_Boosting ( flag w_machine_  class_format_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::WeightedSumMachine *") w_machine_)  
  ((-gptr- "Torch::ClassFormat *") class_format_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::Boosting($w_machine_  ,$class_format_); 
     }
     else  
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_Boosting  train (data  measurers )
  
  ((-gptr- "Torch::DataSet *") data)  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::Boosting *)$p)->train($data  ,$measurers)  ; #} 
  ())

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



;;class BoostingMeasurer : public Measurer
(defclass  torch_BoostingMeasurer   torch_Measurer)

(defmethod  torch_BoostingMeasurer  get_inputs ()
  
  (gptr #{ ((Torch::BoostingMeasurer *)$p)->inputs   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_BoostingMeasurer  set_inputs (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::BoostingMeasurer *)$p)->inputs = $s  ; #} 
  ())

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

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

(defmethod  torch_BoostingMeasurer  get_beta ()
  
  (double #{ ((Torch::BoostingMeasurer *)$p)->beta   #} ))

(defmethod  torch_BoostingMeasurer  set_beta (s )
  
  ((-double-) s)  
  #{ ((Torch::BoostingMeasurer *)$p)->beta = $s  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  get_status ()
  
  (gptr #{ ((Torch::BoostingMeasurer *)$p)->status   #} ))        ;; int *  -> gptr

(defmethod  torch_BoostingMeasurer  set_status (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::BoostingMeasurer *)$p)->status = $s  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  get_internal_error ()
  
  (double #{ ((Torch::BoostingMeasurer *)$p)->internal_error   #} ))

(defmethod  torch_BoostingMeasurer  set_internal_error (s )
  
  ((-double-) s)  
  #{ ((Torch::BoostingMeasurer *)$p)->internal_error = $s  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  get_current_example ()
  
  (int #{ ((Torch::BoostingMeasurer *)$p)->current_example   #} ))

(defmethod  torch_BoostingMeasurer  set_current_example (s )
  
  ((-int-) s)  
  #{ ((Torch::BoostingMeasurer *)$p)->current_example = $s  ; #} 
  ())

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

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

(defmethod  torch_BoostingMeasurer  torch_BoostingMeasurer ( flag class_format_  file_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::ClassFormat *") class_format_)  
  ((-gptr- "Torch::XFile *") file_)  
  #{ if($flag == false ) {
            $shell_flag = false;
            $p = new Torch::BoostingMeasurer($class_format_  ,$file_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

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

(defmethod  torch_BoostingMeasurer  setWeights (weights_ )
  
  ((-gptr- "double *") weights_)  
  #{ ((Torch::BoostingMeasurer *)$p)->setWeights($weights_)  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  setInputs (inputs_ )
  
  ((-gptr- "Torch::Sequence *") inputs_)  
  #{ ((Torch::BoostingMeasurer *)$p)->setInputs($inputs_)  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  init_ ()
  
  #{ ((Torch::BoostingMeasurer *)$p)->init_()  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  reset ()
  
  #{ ((Torch::BoostingMeasurer *)$p)->reset()  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  measureExample ()
  
  #{ ((Torch::BoostingMeasurer *)$p)->measureExample()  ; #} 
  ())

(defmethod  torch_BoostingMeasurer  measureIteration ()
  
  #{ ((Torch::BoostingMeasurer *)$p)->measureIteration()  ; #} 
  ())

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



;;class ClassFormatDataSet : public DataSet
(defclass  torch_ClassFormatDataSet   torch_DataSet)

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

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

(defmethod  torch_ClassFormatDataSet  get_class_labels ()
  
  (gptr #{ ((Torch::ClassFormatDataSet *)$p)->class_labels   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_ClassFormatDataSet  set_class_labels (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::ClassFormatDataSet *)$p)->class_labels = $s  ; #} 
  ())

(defmethod  torch_ClassFormatDataSet  torch_ClassFormatDataSet ( flag data_  class_labels_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "Torch::Sequence *") class_labels_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::ClassFormatDataSet($data_  ,$class_labels_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

;;(defmethod  torch_ClassFormatDataSet  torch_ClassFormatDataSet ( flag data_  n_classes )
;;  ((-bool-) flag)
;;  
;;  ((-gptr- "Torch::DataSet *") data_)  
;;  ((-int-) n_classes)  
;;  #{ if($flag == 0) {
;;            $shell_flag = 0;
;;            $p = new Torch::ClassFormatDataSet($data_  ,$n_classes); 
;;     }
;;  #} 
;;  ())

(defmethod  torch_ClassFormatDataSet  getNumberOfFrames (t_  n_input_frames_  n_target_frames_ )
  
  ((-int-) t_)  
  ((-gptr- "int *") n_input_frames_)  
  ((-gptr- "int *") n_target_frames_)  
  #{ ((Torch::ClassFormatDataSet *)$p)->getNumberOfFrames($t_  ,$n_input_frames_  ,$n_target_frames_)  ; #} 
  ())

(defmethod  torch_ClassFormatDataSet  setRealExample (s  set_inputs  set_targets )
  
  ((-int-) s)  
  ((-bool-) set_inputs)  
  ((-bool-) set_targets)  
  #{ ((Torch::ClassFormatDataSet *)$p)->setRealExample($s  ,$set_inputs  ,$set_targets)  ; #} 
  ())

(defmethod  torch_ClassFormatDataSet  preProcess (pre_processing )
  
  ((-gptr- "Torch::PreProcessing *") pre_processing)  
  #{ ((Torch::ClassFormatDataSet *)$p)->preProcess($pre_processing)  ; #} 
  ())

(defmethod  torch_ClassFormatDataSet  pushExample ()
  
  #{ ((Torch::ClassFormatDataSet *)$p)->pushExample()  ; #} 
  ())

(defmethod  torch_ClassFormatDataSet  popExample ()
  
  #{ ((Torch::ClassFormatDataSet *)$p)->popExample()  ; #} 
  ())

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




;;class ClassMeasurer : public Measurer
(defclass  torch_ClassMeasurer   torch_Measurer)

(defmethod  torch_ClassMeasurer  get_internal_error ()
  
  (double #{ ((Torch::ClassMeasurer *)$p)->internal_error   #} ))

(defmethod  torch_ClassMeasurer  set_internal_error (s )
  
  ((-double-) s)  
  #{ ((Torch::ClassMeasurer *)$p)->internal_error = $s  ; #} 
  ())

(defmethod  torch_ClassMeasurer  get_confusion ()
  
  (gptr #{ ((Torch::ClassMeasurer *)$p)->confusion   #} ))        ;; int **  -> gptr

(defmethod  torch_ClassMeasurer  set_confusion (s )
  
  ((-gptr- "int **") s)  
  #{ ((Torch::ClassMeasurer *)$p)->confusion = $s  ; #} 
  ())

(defmethod  torch_ClassMeasurer  get_inputs ()
  
  (gptr #{ ((Torch::ClassMeasurer *)$p)->inputs   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_ClassMeasurer  set_inputs (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::ClassMeasurer *)$p)->inputs = $s  ; #} 
  ())

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

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

(defmethod  torch_ClassMeasurer  get_calc_confusion ()
  
  (bool #{ ((Torch::ClassMeasurer *)$p)->calc_confusion   #} ))

(defmethod  torch_ClassMeasurer  set_calc_confusion (s )
  
  ((-bool-) s)  
  #{ ((Torch::ClassMeasurer *)$p)->calc_confusion = $s  ; #} 
  ())

(defmethod  torch_ClassMeasurer  get_calc_confusion_at_each_iter ()
  
  (bool #{ ((Torch::ClassMeasurer *)$p)->calc_confusion_at_each_iter   #} ))

(defmethod  torch_ClassMeasurer  set_calc_confusion_at_each_iter (s )
  
  ((-bool-) s)  
  #{ ((Torch::ClassMeasurer *)$p)->calc_confusion_at_each_iter = $s  ; #} 
  ())

(defmethod  torch_ClassMeasurer   get_n_classes ()
  
  (int #{ ((Torch::ClassMeasurer *)$p)->n_classes   #} ))

(defmethod  torch_ClassMeasurer  set_n_classes (s )
  
  ((-int-) s)  
  #{ ((Torch::ClassMeasurer *)$p)->n_classes = $s  ; #} 
  ())

(defmethod  torch_ClassMeasurer  torch_ClassMeasurer ( flag inputs_  data_  class_format_  file_  calc_confusion_  calc_confusion_at_each_iter_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Sequence *") inputs_)  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "Torch::ClassFormat *") class_format_)  
  ((-gptr- "Torch::XFile *") file_)  
  ((-bool-) calc_confusion_)  
  ((-bool-) calc_confusion_at_each_iter_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::ClassMeasurer($inputs_  ,$data_  ,$class_format_  ,$file_  ,$calc_confusion_  ,$calc_confusion_at_each_iter_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_ClassMeasurer  printConfusionMatrix ()
  
  #{ ((Torch::ClassMeasurer *)$p)->printConfusionMatrix()  ; #} 
  ())

(defmethod  torch_ClassMeasurer  reset ()
  
  #{ ((Torch::ClassMeasurer *)$p)->reset()  ; #} 
  ())

(defmethod  torch_ClassMeasurer  measureExample ()
  
  #{ ((Torch::ClassMeasurer *)$p)->measureExample()  ; #} 
  ())

(defmethod  torch_ClassMeasurer  measureIteration ()
  
  #{ ((Torch::ClassMeasurer *)$p)->measureIteration()  ; #} 
  ())

(defmethod  torch_ClassMeasurer  measureEnd ()
  
  #{ ((Torch::ClassMeasurer *)$p)->measureEnd()  ; #} 
  ())

(defmethod  torch_ClassMeasurer  init_ ()
  
  #{ ((Torch::ClassMeasurer *)$p)->init_()  ; #} 
  ())

(defmethod  torch_ClassMeasurer  reset_ ()
  
  #{ ((Torch::ClassMeasurer *)$p)->reset_()  ; #} 
  ())

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





;;class ClassNLLMeasurer : public Measurer
(defclass  torch_ClassNLLMeasurer   torch_Measurer)

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

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

(defmethod  torch_ClassNLLMeasurer  get_average_examples ()
  
  (bool #{ ((Torch::ClassNLLMeasurer *)$p)->average_examples   #} ))

(defmethod  torch_ClassNLLMeasurer  set_average_examples (s )
  
  ((-bool-) s)  
  #{ ((Torch::ClassNLLMeasurer *)$p)->average_examples = $s  ; #} 
  ())

(defmethod  torch_ClassNLLMeasurer  get_average_frames ()
  
  (bool #{ ((Torch::ClassNLLMeasurer *)$p)->average_frames   #} ))

(defmethod  torch_ClassNLLMeasurer  set_average_frames (s )
  
  ((-bool-) s)  
  #{ ((Torch::ClassNLLMeasurer *)$p)->average_frames = $s  ; #} 
  ())

(defmethod  torch_ClassNLLMeasurer  get_internal_error ()
  
  (double #{ ((Torch::ClassNLLMeasurer *)$p)->internal_error   #} ))

(defmethod  torch_ClassNLLMeasurer  set_internal_error (s )
  
  ((-double-) s)  
  #{ ((Torch::ClassNLLMeasurer *)$p)->internal_error = $s  ; #} 
  ())

(defmethod  torch_ClassNLLMeasurer  get_inputs ()
  
  (gptr #{ ((Torch::ClassNLLMeasurer *)$p)->inputs   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_ClassNLLMeasurer  set_inputs (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::ClassNLLMeasurer *)$p)->inputs = $s  ; #} 
  ())

(defmethod  torch_ClassNLLMeasurer  torch_ClassNLLMeasurer ( flag inputs_  data_  class_format_  file_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Sequence *") inputs_)  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "Torch::ClassFormat *") class_format_)  
  ((-gptr- "Torch::XFile *") file_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::ClassNLLMeasurer($inputs_  ,$data_  ,$class_format_  ,$file_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_ClassNLLMeasurer  reset ()
  
  #{ ((Torch::ClassNLLMeasurer *)$p)->reset()  ; #} 
  ())

(defmethod  torch_ClassNLLMeasurer  measureExample ()
  
  #{ ((Torch::ClassNLLMeasurer *)$p)->measureExample()  ; #} 
  ())

(defmethod  torch_ClassNLLMeasurer  measureIteration ()
  
  #{ ((Torch::ClassNLLMeasurer *)$p)->measureIteration()  ; #} 
  ())

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
















;;class DiskDataSet : public DataSet
(defclass  torch_DiskDataSet   torch_DataSet)

(defmethod  torch_DiskDataSet  get_pre_processes ()
  
  (gptr #{ ((Torch::DiskDataSet *)$p)->pre_processes   #} ))        ;; PreProcessingList *  -> gptr

(defmethod  torch_DiskDataSet  set_pre_processes (s )
  
  ((-gptr- "Torch::PreProcessingList *") s)  
  #{ ((Torch::DiskDataSet *)$p)->pre_processes = $s  ; #} 
  ())

(defmethod  torch_DiskDataSet  get_io_inputs ()
  
  (gptr #{ ((Torch::DiskDataSet *)$p)->io_inputs   #} ))        ;; IOSequence *  -> gptr

(defmethod  torch_DiskDataSet  set_io_inputs (s )
  
  ((-gptr- "Torch::IOSequence *") s)  
  #{ ((Torch::DiskDataSet *)$p)->io_inputs = $s  ; #} 
  ())

(defmethod  torch_DiskDataSet  get_io_targets ()
  
  (gptr #{ ((Torch::DiskDataSet *)$p)->io_targets   #} ))        ;; IOSequence *  -> gptr

(defmethod  torch_DiskDataSet  set_io_targets (s )
  
  ((-gptr- "Torch::IOSequence *") s)  
  #{ ((Torch::DiskDataSet *)$p)->io_targets = $s  ; #} 
  ())

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

(defmethod  torch_DiskDataSet  init (io_inputs_  io_targets_ )
  
  ((-gptr- "Torch::IOSequence *") io_inputs_)  
  ((-gptr- "Torch::IOSequence *") io_targets_)  
  #{ ((Torch::DiskDataSet *)$p)->init($io_inputs_  ,$io_targets_)  ; #} 
  ())

(defmethod  torch_DiskDataSet  getNumberOfFrames (s  n_input_frames  n_target_frames )
  
  ((-int-) s)  
  ((-gptr- "int *") n_input_frames)  
  ((-gptr- "int *") n_target_frames)  
  #{ ((Torch::DiskDataSet *)$p)->getNumberOfFrames($s  ,$n_input_frames  ,$n_target_frames)  ; #} 
  ())

(defmethod  torch_DiskDataSet  preProcess (pre_processing )
  
  ((-gptr- "Torch::PreProcessing *") pre_processing)  
  #{ ((Torch::DiskDataSet *)$p)->preProcess($pre_processing)  ; #} 
  ())

(defmethod  torch_DiskDataSet  setRealExample (s  set_inputs  set_targets )
  
  ((-int-) s)  
  ((-bool-) set_inputs)  
  ((-bool-) set_targets)  
  #{ ((Torch::DiskDataSet *)$p)->setRealExample($s  ,$set_inputs  ,$set_targets)  ; #} 
  ())

(defmethod  torch_DiskDataSet  pushExample ()
  
  #{ ((Torch::DiskDataSet *)$p)->pushExample()  ; #} 
  ())

(defmethod  torch_DiskDataSet  popExample ()
  
  #{ ((Torch::DiskDataSet *)$p)->popExample()  ; #} 
  ())

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









;;class DiskXFile : public XFile
(defclass  torch_DiskXFile   torch_XFile)

(defmethod  torch_DiskXFile  get_file ()
  
  (gptr #{ ((Torch::DiskXFile *)$p)->file   #} ))        ;; FILE *  -> gptr

(defmethod  torch_DiskXFile  set_file (s )
  
  ((-gptr- "FILE *") s)  
  #{ ((Torch::DiskXFile *)$p)->file = $s  ; #} 
  ())

(defmethod  torch_DiskXFile  get_is_opened ()
  
  (bool #{ ((Torch::DiskXFile *)$p)->is_opened   #} ))

(defmethod  torch_DiskXFile  set_is_opened (s )
  
  ((-bool-) s)  
  #{ ((Torch::DiskXFile *)$p)->is_opened = $s  ; #} 
  ())

(defmethod  torch_DiskXFile  get_its_a_pipe ()
  
  (bool #{ ((Torch::DiskXFile *)$p)->its_a_pipe   #} ))

(defmethod  torch_DiskXFile  set_its_a_pipe (s )
  
  ((-bool-) s)  
  #{ ((Torch::DiskXFile *)$p)->its_a_pipe = $s  ; #} 
  ())

(defmethod  torch_DiskXFile  torch_DiskXFile ( flag file_name  open_flags )
  ((-bool-) flag)
  
  ((-str-) file_name)  
  ((-str-) open_flags)  
  #{ if($flag == false ) {
            $shell_flag = false;
            $p = new Torch::DiskXFile((const char *)$file_name->data  ,(const char *)$open_flags->data); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

;;(defmethod  torch_DiskXFile  torch_DiskXFile ( flag file_ )
;;  ((-bool-) flag)
;;  
;;  ((-gptr- "FILE *") file_)  
;;  #{ if($flag == 0) {
;;            $shell_flag = 0;
;;            $p = new Torch::DiskXFile($file_); 
;;     }
;;  #} 
;;  ())

(defmethod  torch_DiskXFile  isLittleEndianProcessor ()
  
  (bool #{ Torch::DiskXFile::isLittleEndianProcessor()  #} ))

(defmethod  torch_DiskXFile  isBigEndianProcessor ()
  
  (bool #{ Torch::DiskXFile::isBigEndianProcessor()  #} ))

(defmethod  torch_DiskXFile  isNativeMode ()
  
  (bool #{ Torch::DiskXFile::isNativeMode()  #} ))

(defmethod  torch_DiskXFile  setNativeMode ()
  
  #{ Torch::DiskXFile::setNativeMode()  ; #} 
  ())

(defmethod  torch_DiskXFile  setLittleEndianMode ()
  
  #{ Torch::DiskXFile::setLittleEndianMode()  ; #} 
  ())

(defmethod  torch_DiskXFile  setBigEndianMode ()
  
  #{ Torch::DiskXFile::setBigEndianMode()  ; #} 
  ())

(defmethod  torch_DiskXFile  read (ptr  block_size  n_blocks )
  
  ((-gptr-) ptr)  
  ((-int-) block_size)  
  ((-int-) n_blocks)  
  (int #{ ((Torch::DiskXFile *)$p)->read($ptr  ,$block_size  ,$n_blocks)  #} ))

(defmethod  torch_DiskXFile  write (ptr  block_size  n_blocks )
  
  ((-gptr-) ptr)  
  ((-int-) block_size)  
  ((-int-) n_blocks)  
  (int #{ ((Torch::DiskXFile *)$p)->write($ptr  ,$block_size  ,$n_blocks)  #} ))

(defmethod  torch_DiskXFile  eof ()
  
  (int #{ ((Torch::DiskXFile *)$p)->eof()  #} ))

(defmethod  torch_DiskXFile  flush ()
  
  (int #{ ((Torch::DiskXFile *)$p)->flush()  #} ))

(defmethod  torch_DiskXFile  seek (offset  whence )
  
  ((-int-) offset)   ;; long -> int
  ((-int-) whence)  
  (int #{ ((Torch::DiskXFile *)$p)->seek($offset  ,$whence)  #} ))

(defmethod  torch_DiskXFile  tell ()
  
  (int #{ ((Torch::DiskXFile *)$p)->tell()  #} ))     ;; long -> int

(defmethod  torch_DiskXFile  rewind ()
  
  #{ ((Torch::DiskXFile *)$p)->rewind()  ; #} 
  ())

(defmethod  torch_DiskXFile  scanf (format  ptr )
  
  ((-gptr- "const char *") format)  
  ((-gptr-) ptr)  
  (int #{ ((Torch::DiskXFile *)$p)->scanf($format  ,$ptr)  #} ))

(defmethod  torch_DiskXFile  gets (dest  size_ )
  
  ((-gptr- "char *") dest)  
  ((-int-) size_)  
  (gptr #{ ((Torch::DiskXFile *)$p)->gets($dest  ,$size_)  #} ))        ;; char *  -> gptr

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







;;class EMTrainer : public Trainer
(defclass  torch_EMTrainer   torch_Trainer)

(defmethod  torch_EMTrainer  get_distribution ()
  
  (gptr #{ ((Torch::EMTrainer *)$p)->distribution   #} ))        ;; Distribution *  -> gptr

(defmethod  torch_EMTrainer  set_distribution (s )
  
  ((-gptr- "Torch::Distribution *") s)  
  #{ ((Torch::EMTrainer *)$p)->distribution = $s  ; #} 
  ())

(defmethod  torch_EMTrainer  get_end_accuracy ()
  
  (double #{ ((Torch::EMTrainer *)$p)->end_accuracy   #} ))

(defmethod  torch_EMTrainer  set_end_accuracy (s )
  
  ((-double-) s)  
  #{ ((Torch::EMTrainer *)$p)->end_accuracy = $s  ; #} 
  ())

(defmethod  torch_EMTrainer  get_max_iter ()
  
  (int #{ ((Torch::EMTrainer *)$p)->max_iter   #} ))

(defmethod  torch_EMTrainer  set_max_iter (s )
  
  ((-int-) s)  
  #{ ((Torch::EMTrainer *)$p)->max_iter = $s  ; #} 
  ())

(defmethod  torch_EMTrainer  get_viterbi ()
  
  (bool #{ ((Torch::EMTrainer *)$p)->viterbi   #} ))

(defmethod  torch_EMTrainer  set_viterbi (s )
  
  ((-bool-) s)  
  #{ ((Torch::EMTrainer *)$p)->viterbi = $s  ; #} 
  ())

(defmethod  torch_EMTrainer  torch_EMTrainer ( flag distribution_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Distribution *") distribution_)  
  #{ if($flag == false ) {
            $shell_flag = false;
            $p = new Torch::EMTrainer($distribution_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_EMTrainer  train (data  measurers )
  
  ((-gptr- "Torch::DataSet*") data)  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::EMTrainer *)$p)->train($data  ,$measurers)  ; #} 
  ())

(defmethod  torch_EMTrainer  test (measurers )
  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::EMTrainer *)$p)->test($measurers)  ; #} 
  ())

(defmethod  torch_EMTrainer  decode (measurers )
  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::EMTrainer *)$p)->decode($measurers)  ; #} 
  ())

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



;;class ExampleFrameSelectorDataSet : public DataSet
(defclass  torch_ExampleFrameSelectorDataSet   torch_DataSet)

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

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

(defmethod  torch_ExampleFrameSelectorDataSet  get_n_selected_input_frames ()
  
  (gptr #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->n_selected_input_frames   #} ))        ;; int *  -> gptr

(defmethod  torch_ExampleFrameSelectorDataSet  set_n_selected_input_frames (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->n_selected_input_frames = $s  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  get_n_selected_target_frames ()
  
  (gptr #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->n_selected_target_frames   #} ))        ;; int *  -> gptr

(defmethod  torch_ExampleFrameSelectorDataSet  set_n_selected_target_frames (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->n_selected_target_frames = $s  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  get_input_frames_indices ()
  
  (gptr #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->input_frames_indices   #} ))        ;; int **  -> gptr

(defmethod  torch_ExampleFrameSelectorDataSet  set_input_frames_indices (s )
  
  ((-gptr- "int **") s)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->input_frames_indices = $s  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  get_target_frames_indices ()
  
  (gptr #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->target_frames_indices   #} ))        ;; int **  -> gptr

(defmethod  torch_ExampleFrameSelectorDataSet  set_target_frames_indices (s )
  
  ((-gptr- "int **") s)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->target_frames_indices = $s  ; #} 
  ())

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

(defmethod  torch_ExampleFrameSelectorDataSet  addExample (s  inputs_start_indices_ n_inputs_frames_  targets_start_indices_ n_targets_frames_ )
  
  ((-int-) s) 
  ((-int-)  inputs_start_indices_) 
  ((-int-)  n_inputs_frames_)  
  ((-int-)  targets_start_indices_)  
  ((-int-)  n_targets_frames_)
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->addExample($s  ,$inputs_start_indices_  ,$n_inputs_frames_  ,$targets_start_indices_  ,$n_targets_frames_) ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  removeExample (s )
  
  ((-int-) s)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->removeExample($s )  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  getNumberOfFrames (t_  n_input_frames_  n_target_frames_ )
  
  ((-int-) t_)  
  ((-gptr- "int *") n_input_frames_)  
  ((-gptr- "int *") n_target_frames_)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->getNumberOfFrames($t_  ,$n_input_frames_  ,$n_target_frames_)  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  setRealExample (s  set_inputs  set_targets )
  
  ((-int-) s)  
  ((-bool-) set_inputs)  
  ((-bool-) set_targets)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->setRealExample($s ,$set_inputs ,$set_targets)  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  pushExample ()
  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->pushExample()  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  popExample ()
  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->popExample()  ; #} 
  ())

(defmethod  torch_ExampleFrameSelectorDataSet  preProcess (pre_processing )
  
  ((-gptr- "Torch::PreProcessing *") pre_processing)  
  #{ ((Torch::ExampleFrameSelectorDataSet *)$p)->preProcess($pre_processing)  ; #} 
  ())

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





;;class FrameSelectorDataSet : public DataSet
(defclass  torch_FrameSelectorDataSet   torch_DataSet)

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

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

(defmethod  torch_FrameSelectorDataSet  get_n_selected_input_frames ()
  
  (gptr #{ ((Torch::FrameSelectorDataSet *)$p)->n_selected_input_frames   #} ))        ;; int *  -> gptr

(defmethod  torch_FrameSelectorDataSet  set_n_selected_input_frames (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->n_selected_input_frames = $s  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  get_n_selected_target_frames ()
  
  (gptr #{ ((Torch::FrameSelectorDataSet *)$p)->n_selected_target_frames   #} ))        ;; int *  -> gptr

(defmethod  torch_FrameSelectorDataSet  set_n_selected_target_frames (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->n_selected_target_frames = $s  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  get_input_frames_indices ()
  
  (gptr #{ ((Torch::FrameSelectorDataSet *)$p)->input_frames_indices   #} ))        ;; int **  -> gptr

(defmethod  torch_FrameSelectorDataSet  set_input_frames_indices (s )
  
  ((-gptr- "int **") s)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->input_frames_indices = $s  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  get_target_frames_indices ()
  
  (gptr #{ ((Torch::FrameSelectorDataSet *)$p)->target_frames_indices   #} ))        ;; int **  -> gptr

(defmethod  torch_FrameSelectorDataSet  set_target_frames_indices (s )
  
  ((-gptr- "int **") s)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->target_frames_indices = $s  ; #} 
  ())

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

(defmethod  torch_FrameSelectorDataSet  selectInputFrames (t_  frames_indices_  n_frames_ )
  
  ((-int-) t_)  
  ((-gptr- "int *") frames_indices_)  
  ((-int-) n_frames_)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->selectInputFrames($t_  ,$frames_indices_  ,$n_frames_)  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  selectTargetFrames (t_  frames_indices_  n_frames_ )
  
  ((-int-) t_)  
  ((-gptr- "int *") frames_indices_)  
  ((-int-) n_frames_)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->selectTargetFrames($t_  ,$frames_indices_  ,$n_frames_)  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  unselectInputFrames (t_ )
  
  ((-int-) t_)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->unselectInputFrames($t_)  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  unselectTargetFrames (t_ )
  
  ((-int-) t_)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->unselectTargetFrames($t_)  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  preProcess (pre_processing )
  
  ((-gptr- "Torch::PreProcessing *") pre_processing)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->preProcess($pre_processing)  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  getNumberOfFrames (t_  n_input_frames_  n_target_frames_ )
  
  ((-int-) t_)  
  ((-gptr- "int *") n_input_frames_)  
  ((-gptr- "int *") n_target_frames_)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->getNumberOfFrames($t_  ,$n_input_frames_  ,$n_target_frames_)  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  setRealExample (s  set_inputs  set_targets )
  
  ((-int-) s)  
  ((-bool-) set_inputs)  
  ((-bool-) set_targets)  
  #{ ((Torch::FrameSelectorDataSet *)$p)->setRealExample($s  ,$set_inputs  ,$set_targets)  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  pushExample ()
  
  #{ ((Torch::FrameSelectorDataSet *)$p)->pushExample()  ; #} 
  ())

(defmethod  torch_FrameSelectorDataSet  popExample ()
  
  #{ ((Torch::FrameSelectorDataSet *)$p)->popExample()  ; #} 
  ())

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









;;class IOAscii : public IOSequence
(defclass  torch_IOAscii   torch_IOSequence)

(defmethod  torch_IOAscii  get_one_file_is_one_sequence ()
  
  (bool #{ ((Torch::IOAscii *)$p)->one_file_is_one_sequence   #} ))

(defmethod  torch_IOAscii  set_one_file_is_one_sequence (s )
  
  ((-bool-) s)  
  #{ ((Torch::IOAscii *)$p)->one_file_is_one_sequence = $s  ; #} 
  ())

(defmethod  torch_IOAscii  get_n_total_frames ()
  
  (int #{ ((Torch::IOAscii *)$p)->n_total_frames   #} ))

(defmethod  torch_IOAscii  set_n_total_frames (s )
  
  ((-int-) s)  
  #{ ((Torch::IOAscii *)$p)->n_total_frames = $s  ; #} 
  ())

(defmethod  torch_IOAscii  get_filename ()
  
  (gptr #{ ((Torch::IOAscii *)$p)->filename   #} ))        ;; char *  -> gptr

(defmethod  torch_IOAscii  set_filename (s )
  
  ((-gptr- "char *") s)  
  #{ ((Torch::IOAscii *)$p)->filename = $s  ; #} 
  ())

(defmethod  torch_IOAscii  get_max_load ()
  
  (int #{ ((Torch::IOAscii *)$p)->max_load   #} ))

(defmethod  torch_IOAscii  set_max_load (s )
  
  ((-int-) s)  
  #{ ((Torch::IOAscii *)$p)->max_load = $s  ; #} 
  ())

(defmethod  torch_IOAscii  torch_IOAscii ( flag filename_  one_file_is_one_sequence_  max_load_ )
  ((-bool-) flag)
  
  ((-str-) filename_)  
  ((-bool-) one_file_is_one_sequence_)  
  ((-int-) max_load_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::IOAscii( (const char *)(($filename_)->data),$one_file_is_one_sequence_  ,$max_load_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_IOAscii  saveSequence (file  sequence )
  
  ((-gptr- "Torch::XFile *") file)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ Torch::IOAscii::saveSequence($file  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOAscii  getSequence (s  sequence )
  
  ((-int-) s)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::IOAscii *)$p)->getSequence($s  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOAscii  getNumberOfFrames (s )
  
  ((-int-) s)  
  (int #{ ((Torch::IOAscii *)$p)->getNumberOfFrames($s)  #} ))

(defmethod  torch_IOAscii  getTotalNumberOfFrames ()
  
  (int #{ ((Torch::IOAscii *)$p)->getTotalNumberOfFrames()  #} ))

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



;;class IOBin : public IOSequence
(defclass  torch_IOBin   torch_IOSequence)

(defmethod  torch_IOBin  get_one_file_is_one_sequence ()
  
  (bool #{ ((Torch::IOBin *)$p)->one_file_is_one_sequence   #} ))

(defmethod  torch_IOBin  set_one_file_is_one_sequence (s )
  
  ((-bool-) s)  
  #{ ((Torch::IOBin *)$p)->one_file_is_one_sequence = $s  ; #} 
  ())

(defmethod  torch_IOBin  get_n_total_frames ()
  
  (int #{ ((Torch::IOBin *)$p)->n_total_frames   #} ))

(defmethod  torch_IOBin  set_n_total_frames (s )
  
  ((-int-) s)  
  #{ ((Torch::IOBin *)$p)->n_total_frames = $s  ; #} 
  ())

(defmethod  torch_IOBin  get_filename ()
  
  (gptr #{ ((Torch::IOBin *)$p)->filename   #} ))        ;; char *  -> gptr

(defmethod  torch_IOBin  set_filename (s )
  
  ((-gptr- "char *") s)  
  #{ ((Torch::IOBin *)$p)->filename = $s  ; #} 
  ())

(defmethod  torch_IOBin  get_max_load ()
  
  (int #{ ((Torch::IOBin *)$p)->max_load   #} ))

(defmethod  torch_IOBin  set_max_load (s )
  
  ((-int-) s)  
  #{ ((Torch::IOBin *)$p)->max_load = $s  ; #} 
  ())

(defmethod  torch_IOBin  get_is_sequential ()
  
  (bool #{ ((Torch::IOBin *)$p)->is_sequential   #} ))

(defmethod  torch_IOBin  set_is_sequential (s )
  
  ((-bool-) s)  
  #{ ((Torch::IOBin *)$p)->is_sequential = $s  ; #} 
  ())

(defmethod  torch_IOBin  torch_IOBin ( flag filename_  one_file_is_one_sequence_  max_load_  is_sequential )
  ((-bool-) flag)
  
  ((-gptr- "const char *") filename_)  
  ((-bool-) one_file_is_one_sequence_)  
  ((-int-) max_load_)  
  ((-bool-) is_sequential)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::IOBin($filename_  ,$one_file_is_one_sequence_  ,$max_load_  ,$is_sequential); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_IOBin  saveSequence (file  sequence )
  
  ((-gptr- "Torch::XFile *") file)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ Torch::IOBin::saveSequence($file  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOBin  getSequence (s  sequence )
  
  ((-int-) s)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::IOBin *)$p)->getSequence($s  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOBin  getNumberOfFrames (s )
  
  ((-int-) s)  
  (int #{ ((Torch::IOBin *)$p)->getNumberOfFrames($s)  #} ))

(defmethod  torch_IOBin  getTotalNumberOfFrames ()
  
  (int #{ ((Torch::IOBin *)$p)->getTotalNumberOfFrames()  #} ))

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



;;class IOBufferize : public IOSequence
(defclass  torch_IOBufferize   torch_IOSequence)

(defmethod  torch_IOBufferize  get_io_torch ()
  
  (gptr #{ ((Torch::IOBufferize *)$p)->io_torch   #} ))        ;; IOSequence *  -> gptr

(defmethod  torch_IOBufferize  set_io_torch (s )
  
  ((-gptr- "Torch::IOSequence *") s)  
  #{ ((Torch::IOBufferize *)$p)->io_torch = $s  ; #} 
  ())

(defmethod  torch_IOBufferize  get_bufferized_sequence ()
  
  (gptr #{ ((Torch::IOBufferize *)$p)->bufferized_sequence   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_IOBufferize  set_bufferized_sequence (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::IOBufferize *)$p)->bufferized_sequence = $s  ; #} 
  ())

(defmethod  torch_IOBufferize  get_bufferized_sequence_index ()
  
  (int #{ ((Torch::IOBufferize *)$p)->bufferized_sequence_index   #} ))

(defmethod  torch_IOBufferize  set_bufferized_sequence_index (s )
  
  ((-int-) s)  
  #{ ((Torch::IOBufferize *)$p)->bufferized_sequence_index = $s  ; #} 
  ())

(defmethod  torch_IOBufferize  torch_IOBufferize ( flag io_torch_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::IOSequence *") io_torch_)  
  #{ if($flag == false ) {
            $shell_flag = false;
            $p = new Torch::IOBufferize($io_torch_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_IOBufferize  bufferizeSequence (s )
  
  ((-int-) s)  
  #{ ((Torch::IOBufferize *)$p)->bufferizeSequence($s)  ; #} 
  ())

(defmethod  torch_IOBufferize  getSequence (s  sequence )
  
  ((-int-) s)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::IOBufferize *)$p)->getSequence($s  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOBufferize  getNumberOfFrames (s )
  
  ((-int-) s)  
  (int #{ ((Torch::IOBufferize *)$p)->getNumberOfFrames($s)  #} ))

(defmethod  torch_IOBufferize  getTotalNumberOfFrames ()
  
  (int #{ ((Torch::IOBufferize *)$p)->getTotalNumberOfFrames()  #} ))

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



;;class IOHTK : public IOSequence
(defclass  torch_IOHTK   torch_IOSequence)

(defmethod  torch_IOHTK  get_one_file_is_one_sequence ()
  
  (bool #{ ((Torch::IOHTK *)$p)->one_file_is_one_sequence   #} ))

(defmethod  torch_IOHTK  set_one_file_is_one_sequence (s )
  
  ((-bool-) s)  
  #{ ((Torch::IOHTK *)$p)->one_file_is_one_sequence = $s  ; #} 
  ())

(defmethod  torch_IOHTK  get_n_total_frames ()
  
  (int #{ ((Torch::IOHTK *)$p)->n_total_frames   #} ))

(defmethod  torch_IOHTK  set_n_total_frames (s )
  
  ((-int-) s)  
  #{ ((Torch::IOHTK *)$p)->n_total_frames = $s  ; #} 
  ())

(defmethod  torch_IOHTK  get_filename ()
  
  (gptr #{ ((Torch::IOHTK *)$p)->filename   #} ))        ;; char *  -> gptr

(defmethod  torch_IOHTK  set_filename (s )
  
  ((-gptr- "char *") s)  
  #{ ((Torch::IOHTK *)$p)->filename = $s  ; #} 
  ())

(defmethod  torch_IOHTK  get_max_load ()
  
  (int #{ ((Torch::IOHTK *)$p)->max_load   #} ))

(defmethod  torch_IOHTK  set_max_load (s )
  
  ((-int-) s)  
  #{ ((Torch::IOHTK *)$p)->max_load = $s  ; #} 
  ())

(defmethod  torch_IOHTK  get_is_sequential ()
  
  (bool #{ ((Torch::IOHTK *)$p)->is_sequential   #} ))

(defmethod  torch_IOHTK  set_is_sequential (s )
  
  ((-bool-) s)  
  #{ ((Torch::IOHTK *)$p)->is_sequential = $s  ; #} 
  ())

(defmethod  torch_IOHTK  get_header ()
  
  (gptr #{ ((Torch::IOHTK *)$p)->header   #} ))        ;; HTKHeader*  -> gptr

(defmethod  torch_IOHTK  set_header (s )
  
  ((-gptr- "Torch::HTKHeader*") s)  
  #{ ((Torch::IOHTK *)$p)->header = $s  ; #} 
  ())

(defmethod  torch_IOHTK  torch_IOHTK ( flag filename_  one_file_is_one_sequence_  max_load_  is_sequential_ )
  ((-bool-) flag)
  
  ((-gptr- "const char *") filename_)  
  ((-bool-) one_file_is_one_sequence_)  
  ((-int-) max_load_)  
  ((-bool-) is_sequential_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::IOHTK($filename_  ,$one_file_is_one_sequence_  ,$max_load_  ,$is_sequential_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_IOHTK  saveSequence (file  sequence  header_ )
  
  ((-gptr- "Torch::XFile *") file)  
  ((-gptr- "Torch::Sequence *") sequence)  
  ((-gptr- "Torch::HTKHeader*") header_)  
  #{ Torch::IOHTK::saveSequence($file  ,$sequence  ,$header_)  ; #} 
  ())

(defmethod  torch_IOHTK  getSequence (s  sequence )
  
  ((-int-) s)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::IOHTK *)$p)->getSequence($s  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOHTK  getNumberOfFrames (s )
  
  ((-int-) s)  
  (int #{ ((Torch::IOHTK *)$p)->getNumberOfFrames($s)  #} ))

(defmethod  torch_IOHTK  getTotalNumberOfFrames ()
  
  (int #{ ((Torch::IOHTK *)$p)->getTotalNumberOfFrames()  #} ))

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

(defmethod  torch_IOHTK  parmKind2Str (kind  buf )
  
  ((-int-) kind)  
  ((-gptr- "char *") buf)  
  (gptr #{ ((Torch::IOHTK *)$p)->parmKind2Str($kind  ,$buf)  #} ))        ;; char*  -> gptr

(defmethod  torch_IOHTK  str2ParmKind (str )
  
  ((-gptr- "char *") str)  
  (int #{ ((Torch::IOHTK *)$p)->str2ParmKind($str)  #} ))

(defmethod  torch_IOHTK  baseParmKind (kind )
  
  ((-int-) kind)  
  (int #{ ((Torch::IOHTK *)$p)->baseParmKind($kind)  #} ))

(defmethod  torch_IOHTK  hasEnergy (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasEnergy($kind)  #} ))

(defmethod  torch_IOHTK  hasDelta (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasDelta($kind)  #} ))

(defmethod  torch_IOHTK  hasAccs (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasAccs($kind)  #} ))

(defmethod  torch_IOHTK  hasNulle (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasNulle($kind)  #} ))

(defmethod  torch_IOHTK  hasCompx (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasCompx($kind)  #} ))

(defmethod  torch_IOHTK  hasCrcc (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasCrcc($kind)  #} ))

(defmethod  torch_IOHTK  hasZerom (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasZerom($kind)  #} ))

(defmethod  torch_IOHTK  hasZeroc (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasZeroc($kind)  #} ))

(defmethod  torch_IOHTK  hasVQ (kind )
  
  ((-int-) kind)  
  (bool #{ ((Torch::IOHTK *)$p)->hasVQ($kind)  #} ))



;;class IOHTKTarget : public IOSequence
(defclass  torch_IOHTKTarget   torch_IOSequence)

(defmethod  torch_IOHTKTarget  get_one_file_is_one_sequence ()
  
  (bool #{ ((Torch::IOHTKTarget *)$p)->one_file_is_one_sequence   #} ))

(defmethod  torch_IOHTKTarget  set_one_file_is_one_sequence (s )
  
  ((-bool-) s)  
  #{ ((Torch::IOHTKTarget *)$p)->one_file_is_one_sequence = $s  ; #} 
  ())

(defmethod  torch_IOHTKTarget  get_n_total_frames ()
  
  (int #{ ((Torch::IOHTKTarget *)$p)->n_total_frames   #} ))

(defmethod  torch_IOHTKTarget  set_n_total_frames (s )
  
  ((-int-) s)  
  #{ ((Torch::IOHTKTarget *)$p)->n_total_frames = $s  ; #} 
  ())

(defmethod  torch_IOHTKTarget  get_filename ()
  
  (gptr #{ ((Torch::IOHTKTarget *)$p)->filename   #} ))        ;; char *  -> gptr

(defmethod  torch_IOHTKTarget  set_filename (s )
  
  ((-gptr- "char *") s)  
  #{ ((Torch::IOHTKTarget *)$p)->filename = $s  ; #} 
  ())

(defmethod  torch_IOHTKTarget  get_max_load ()
  
  (int #{ ((Torch::IOHTKTarget *)$p)->max_load   #} ))

(defmethod  torch_IOHTKTarget  set_max_load (s )
  
  ((-int-) s)  
  #{ ((Torch::IOHTKTarget *)$p)->max_load = $s  ; #} 
  ())

(defmethod  torch_IOHTKTarget  get_n_per_frame ()
  
  (int #{ ((Torch::IOHTKTarget *)$p)->n_per_frame   #} ))

(defmethod  torch_IOHTKTarget  set_n_per_frame (s )
  
  ((-int-) s)  
  #{ ((Torch::IOHTKTarget *)$p)->n_per_frame = $s  ; #} 
  ())

(defmethod  torch_IOHTKTarget  get_lexicon ()
  
  (gptr #{ ((Torch::IOHTKTarget *)$p)->lexicon   #} ))        

(defmethod  torch_IOHTKTarget  set_lexicon (s )
  
  ((-gptr- "Torch::LexiconInfo *") s)  
  #{ ((Torch::IOHTKTarget *)$p)->lexicon = $s  ; #} 
  ())

(defmethod  torch_IOHTKTarget  get_words ()
  
  (bool #{ ((Torch::IOHTKTarget *)$p)->words   #} ))

(defmethod  torch_IOHTKTarget  set_words (s )
  
  ((-bool-) s)  
  #{ ((Torch::IOHTKTarget *)$p)->words = $s  ; #} 
  ())

(defmethod  torch_IOHTKTarget  torch_IOHTKTarget ( flag filename_  lex_  n_per_frame_  words )
  ((-bool-) flag)
  
  ((-gptr- "const char *") filename_)  
  ((-gptr- "Torch::LexiconInfo *") lex_)  
  ((-int-) n_per_frame_)  
  ((-bool-) words)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::IOHTKTarget($filename_  ,$lex_  ,$n_per_frame_  ,$words); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_IOHTKTarget  saveSequence (file  sequence  lex_  n_per_frame_  words_ )
  
  ((-gptr- "Torch::XFile *") file)  
  ((-gptr- "Torch::Sequence *") sequence)  
  ((-gptr- "Torch::LexiconInfo *") lex_)  
  ((-int-) n_per_frame_)  
  ((-bool-) words_)  
  #{ ((Torch::IOHTKTarget *)$p)->saveSequence($file  ,$sequence  ,$lex_  ,$n_per_frame_  ,$words_)  ; #} 
  ())

(defmethod  torch_IOHTKTarget  getSequence (s  sequence )
  
  ((-int-) s)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::IOHTKTarget *)$p)->getSequence($s  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOHTKTarget  getNumberOfFrames (s )
  
  ((-int-) s)  
  (int #{ ((Torch::IOHTKTarget *)$p)->getNumberOfFrames($s)  #} ))

(defmethod  torch_IOHTKTarget  getTotalNumberOfFrames ()
  
  (int #{ ((Torch::IOHTKTarget *)$p)->getTotalNumberOfFrames()  #} ))

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



;;class IOMulti : public IOSequence
(defclass  torch_IOMulti   torch_IOSequence)

(defmethod  torch_IOMulti  get_io_files ()
  
  (gptr #{ ((Torch::IOMulti *)$p)->io_files   #} ))        ;; IOSequence **  -> gptr

(defmethod  torch_IOMulti  set_io_files (s )
  
  ((-gptr- "Torch::IOSequence **") s)  
  #{ ((Torch::IOMulti *)$p)->io_files = $s  ; #} 
  ())

(defmethod  torch_IOMulti  get_n_files ()
  
  (int #{ ((Torch::IOMulti *)$p)->n_files   #} ))

(defmethod  torch_IOMulti  set_n_files (s )
  
  ((-int-) s)  
  #{ ((Torch::IOMulti *)$p)->n_files = $s  ; #} 
  ())

(defmethod  torch_IOMulti  get_indices ()
  
  (gptr #{ ((Torch::IOMulti *)$p)->indices   #} ))        ;; int *  -> gptr

(defmethod  torch_IOMulti  set_indices (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::IOMulti *)$p)->indices = $s  ; #} 
  ())

(defmethod  torch_IOMulti  get_offsets ()
  
  (gptr #{ ((Torch::IOMulti *)$p)->offsets   #} ))        ;; int *  -> gptr

(defmethod  torch_IOMulti  set_offsets (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::IOMulti *)$p)->offsets = $s  ; #} 
  ())

(defmethod  torch_IOMulti  torch_IOMulti ( flag io_files_  n_files_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::IOSequence **") io_files_)  
  ((-int-) n_files_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::IOMulti($io_files_  ,$n_files_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_IOMulti  getSequence (s  sequence )
  
  ((-int-) s)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::IOMulti *)$p)->getSequence($s  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOMulti  getNumberOfFrames (s )
  
  ((-int-) s)  
  (int #{ ((Torch::IOMulti *)$p)->getNumberOfFrames($s)  #} ))

(defmethod  torch_IOMulti  getTotalNumberOfFrames ()
  
  (int #{ ((Torch::IOMulti *)$p)->getTotalNumberOfFrames()  #} ))

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






;;class IOSub : public IOSequence
(defclass  torch_IOSub   torch_IOSequence)

(defmethod  torch_IOSub  get_io_torch ()
  
  (gptr #{ ((Torch::IOSub *)$p)->io_torch   #} ))        ;; IOBufferize *  -> gptr

(defmethod  torch_IOSub  set_io_torch (s )
  
  ((-gptr- "Torch::IOBufferize *") s)  
  #{ ((Torch::IOSub *)$p)->io_torch = $s  ; #} 
  ())

(defmethod  torch_IOSub  get_offset ()
  
  (int #{ ((Torch::IOSub *)$p)->offset   #} ))

(defmethod  torch_IOSub  set_offset (s )
  
  ((-int-) s)  
  #{ ((Torch::IOSub *)$p)->offset = $s  ; #} 
  ())

(defmethod  torch_IOSub  torch_IOSub ( flag io_torch_  offset_  frame_size_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::IOBufferize *") io_torch_)  
  ((-int-) offset_)  
  ((-int-) frame_size_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::IOSub($io_torch_  ,$offset_  ,$frame_size_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_IOSub  getSequence (s  sequence )
  
  ((-int-) s)  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::IOSub *)$p)->getSequence($s  ,$sequence)  ; #} 
  ())

(defmethod  torch_IOSub  getNumberOfFrames (s )
  
  ((-int-) s)  
  (int #{ ((Torch::IOSub *)$p)->getNumberOfFrames($s)  #} ))

(defmethod  torch_IOSub  getTotalNumberOfFrames ()
  
  (int #{ ((Torch::IOSub *)$p)->getTotalNumberOfFrames()  #} ))

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



;;class DotKernel : public Kernel
(defclass  torch_DotKernel   torch_Kernel)

(defmethod  torch_DotKernel  get_s ()
  
  (double #{ ((Torch::DotKernel *)$p)->s   #} ))

(defmethod  torch_DotKernel  set_s (s )
  
  ((-double-) s)  
  #{ ((Torch::DotKernel *)$p)->s = $s  ; #} 
  ())

(defmethod  torch_DotKernel  torch_DotKernel ( flag s_ )
  ((-bool-) flag)
  
  ((-double-) s_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::DotKernel($s_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_DotKernel  eval (x  y )
  
  ((-gptr- "Torch::Sequence *") x)  
  ((-gptr- "Torch::Sequence *") y)  
  (double #{ ((Torch::DotKernel *)$p)->eval($x  ,$y)  #} ))

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



;;class PolynomialKernel : public Kernel
(defclass  torch_PolynomialKernel   torch_Kernel)

(defmethod  torch_PolynomialKernel  get_d ()
  
  (int #{ ((Torch::PolynomialKernel *)$p)->d   #} ))

(defmethod  torch_PolynomialKernel  set_d (s )
  
  ((-int-) s)  
  #{ ((Torch::PolynomialKernel *)$p)->d = $s  ; #} 
  ())

(defmethod  torch_PolynomialKernel  get_s ()
  
  (double #{ ((Torch::PolynomialKernel *)$p)->s   #} ))

(defmethod  torch_PolynomialKernel  set_s (s )
  
  ((-double-) s)  
  #{ ((Torch::PolynomialKernel *)$p)->s = $s  ; #} 
  ())

(defmethod  torch_PolynomialKernel  get_r ()
  
  (double #{ ((Torch::PolynomialKernel *)$p)->r   #} ))

(defmethod  torch_PolynomialKernel  set_r (s )
  
  ((-double-) s)  
  #{ ((Torch::PolynomialKernel *)$p)->r = $s  ; #} 
  ())

(defmethod  torch_PolynomialKernel  torch_PolynomialKernel ( flag degree  s_  r_ )
  ((-bool-) flag)
  
  ((-int-) degree)  
  ((-int-) s_)  
  ((-int-) r_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::PolynomialKernel($degree  ,$s_  ,$r_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_PolynomialKernel  eval (x  y )
  
  ((-gptr- "Torch::Sequence *") x)  
  ((-gptr- "Torch::Sequence *") y)  
  (double #{ ((Torch::PolynomialKernel *)$p)->eval($x  ,$y)  #} ))

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



;;class GaussianKernel : public Kernel
(defclass  torch_GaussianKernel   torch_Kernel)

(defmethod  torch_GaussianKernel  get_g ()
  
  (double #{ ((Torch::GaussianKernel *)$p)->g   #} ))

(defmethod  torch_GaussianKernel  set_g (s )
  
  ((-double-) s)  
  #{ ((Torch::GaussianKernel *)$p)->g = $s  ; #} 
  ())

(defmethod  torch_GaussianKernel  torch_GaussianKernel ( flag g_ )
  ((-bool-) flag)
  
  ((-double-) g_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = ::new Torch::GaussianKernel($g_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_GaussianKernel  eval (x  y )
  
  ((-gptr- "Torch::Sequence *") x)  
  ((-gptr- "Torch::Sequence *") y)  
  (double #{ ((Torch::GaussianKernel *)$p)->eval($x  ,$y)  #} ))

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



;;class SigmoidKernel : public Kernel
(defclass  torch_SigmoidKernel   torch_Kernel)

(defmethod  torch_SigmoidKernel  get_s ()
  
  (double #{ ((Torch::SigmoidKernel *)$p)->s   #} ))

(defmethod  torch_SigmoidKernel  set_s (s )
  
  ((-double-) s)  
  #{ ((Torch::SigmoidKernel *)$p)->s = $s  ; #} 
  ())

(defmethod  torch_SigmoidKernel  get_r ()
  
  (double #{ ((Torch::SigmoidKernel *)$p)->r   #} ))

(defmethod  torch_SigmoidKernel  set_r (s )
  
  ((-double-) s)  
  #{ ((Torch::SigmoidKernel *)$p)->r = $s  ; #} 
  ())

(defmethod  torch_SigmoidKernel  torch_SigmoidKernel ( flag s_  r_ )
  ((-bool-) flag)
  
  ((-double-) s_)  
  ((-double-) r_)  
  #{ if($flag == false ) {
            $shell_flag = false;
            $p = new Torch::SigmoidKernel($s_  ,$r_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_SigmoidKernel  eval (x  y )
  
  ((-gptr- "Torch::Sequence *") x)  
  ((-gptr- "Torch::Sequence *") y)  
  (double #{ ((Torch::SigmoidKernel *)$p)->eval($x  ,$y)  #} ))

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







;;class KNN : public Machine
(defclass  torch_KNN   torch_Machine)

(defmethod  torch_KNN  get_K ()
  
  (int #{ ((Torch::KNN *)$p)->K   #} ))

(defmethod  torch_KNN  set_K (s )
  
  ((-int-) s)  
  #{ ((Torch::KNN *)$p)->K = $s  ; #} 
  ())

(defmethod  torch_KNN  get_distances ()
  
  (gptr #{ ((Torch::KNN *)$p)->distances   #} ))        ;; real*  -> gptr

(defmethod  torch_KNN  set_distances (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::KNN *)$p)->distances = $s  ; #} 
  ())

(defmethod  torch_KNN  get_indices ()
  
  (gptr #{ ((Torch::KNN *)$p)->indices   #} ))        ;; int*  -> gptr

(defmethod  torch_KNN  set_indices (s )
  
  ((-gptr- "int*") s)  
  #{ ((Torch::KNN *)$p)->indices = $s  ; #} 
  ())

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

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

(defmethod  torch_KNN  get_n_outputs ()
  
  (int #{ ((Torch::KNN *)$p)->n_outputs   #} ))

(defmethod  torch_KNN  set_n_outputs (s )
  
  ((-int-) s)  
  #{ ((Torch::KNN *)$p)->n_outputs = $s  ; #} 
  ())

(defmethod  torch_KNN  get_real_examples ()
  
  (gptr #{ ((Torch::KNN *)$p)->real_examples   #} ))        ;; int *  -> gptr

(defmethod  torch_KNN  set_real_examples (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::KNN *)$p)->real_examples = $s  ; #} 
  ())

(defmethod  torch_KNN  get_n_real_examples ()
  
  (int #{ ((Torch::KNN *)$p)->n_real_examples   #} ))

(defmethod  torch_KNN  set_n_real_examples (s )
  
  ((-int-) s)  
  #{ ((Torch::KNN *)$p)->n_real_examples = $s  ; #} 
  ())

(defmethod  torch_KNN  torch_KNN ( flag n_outputs_  K_ )
  ((-bool-) flag)
  
  ((-int-) n_outputs_)  
  ((-int-) K_)  
  #{ if($flag == false ) {
            $shell_flag = false;
            $p = new Torch::KNN($n_outputs_  ,$K_); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

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

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

(defmethod  torch_KNN  setK (K_ )
  
  ((-int-) K_)  
  #{ ((Torch::KNN *)$p)->setK($K_)  ; #} 
  ())

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














;;class MeanVarNorm : public PreProcessing
(defclass  torch_MeanVarNorm   torch_PreProcessing)

(defmethod  torch_MeanVarNorm  get_n_inputs ()
  
  (int #{ ((Torch::MeanVarNorm *)$p)->n_inputs   #} ))

(defmethod  torch_MeanVarNorm  set_n_inputs (s )
  
  ((-int-) s)  
  #{ ((Torch::MeanVarNorm *)$p)->n_inputs = $s  ; #} 
  ())

(defmethod  torch_MeanVarNorm  get_n_targets ()
  
  (int #{ ((Torch::MeanVarNorm *)$p)->n_targets   #} ))

(defmethod  torch_MeanVarNorm  set_n_targets (s )
  
  ((-int-) s)  
  #{ ((Torch::MeanVarNorm *)$p)->n_targets = $s  ; #} 
  ())

(defmethod  torch_MeanVarNorm  get_inputs_mean ()
  
  (gptr #{ ((Torch::MeanVarNorm *)$p)->inputs_mean   #} ))        ;; double *  -> gptr

(defmethod  torch_MeanVarNorm  set_inputs_mean (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::MeanVarNorm *)$p)->inputs_mean = $s  ; #} 
  ())

(defmethod  torch_MeanVarNorm  get_targets_mean ()
  
  (gptr #{ ((Torch::MeanVarNorm *)$p)->targets_mean   #} ))        ;; double *  -> gptr

(defmethod  torch_MeanVarNorm  set_targets_mean (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::MeanVarNorm *)$p)->targets_mean = $s  ; #} 
  ())

(defmethod  torch_MeanVarNorm  get_inputs_stdv ()
  
  (gptr #{ ((Torch::MeanVarNorm *)$p)->inputs_stdv   #} ))        ;; double *  -> gptr

(defmethod  torch_MeanVarNorm  set_inputs_stdv (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::MeanVarNorm *)$p)->inputs_stdv = $s  ; #} 
  ())

(defmethod  torch_MeanVarNorm  get_targets_stdv ()
  
  (gptr #{ ((Torch::MeanVarNorm *)$p)->targets_stdv   #} ))        ;; double *  -> gptr

(defmethod  torch_MeanVarNorm  set_targets_stdv (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::MeanVarNorm *)$p)->targets_stdv = $s  ; #} 
  ())

(defmethod  torch_MeanVarNorm  torch_MeanVarNorm ( flag data  norm_inputs  norm_targets )
  ((-bool-) flag)
  
  ((-gptr- "Torch::DataSet *") data)  
  ((-bool-) norm_inputs)  
  ((-bool-) norm_targets)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::MeanVarNorm($data  ,$norm_inputs  ,$norm_targets); 
     }
     else 
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_MeanVarNorm  preProcessInputs (inputs )
  
  ((-gptr- "Torch::Sequence *") inputs)  
  #{ ((Torch::MeanVarNorm *)$p)->preProcessInputs($inputs)  ; #} 
  ())

(defmethod  torch_MeanVarNorm  preProcessTargets (targets )
  
  ((-gptr- "Torch::Sequence *") targets)  
  #{ ((Torch::MeanVarNorm *)$p)->preProcessTargets($targets)  ; #} 
  ())

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

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

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





;;class MemoryDataSet : public DataSet
(defclass  torch_MemoryDataSet   torch_DataSet)

(defmethod  torch_MemoryDataSet  get_inputs_array ()
  
  (gptr #{ ((Torch::MemoryDataSet *)$p)->inputs_array   #} ))        ;; Sequence **  -> gptr

(defmethod  torch_MemoryDataSet  set_inputs_array (s )
  
  ((-gptr- "Torch::Sequence **") s)  
  #{ ((Torch::MemoryDataSet *)$p)->inputs_array = $s  ; #} 
  ())

(defmethod  torch_MemoryDataSet  get_targets_array ()
  
  (gptr #{ ((Torch::MemoryDataSet *)$p)->targets_array   #} ))        ;; Sequence **  -> gptr

(defmethod  torch_MemoryDataSet  set_targets_array (s )
  
  ((-gptr- "Torch::Sequence **") s)  
  #{ ((Torch::MemoryDataSet *)$p)->targets_array = $s  ; #} 
  ())

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

(defmethod  torch_MemoryDataSet  init (io_inputs  io_outputs )
  
  ((-gptr- "Torch::IOSequence *") io_inputs)  
  ((-gptr- "Torch::IOSequence *") io_outputs)  
  #{ ((Torch::MemoryDataSet *)$p)->init($io_inputs  ,$io_outputs)  ; #} 
  ())

(defmethod  torch_MemoryDataSet  setInputs (inputs_  n_sequences_ )
  
  ((-gptr- "Torch::Sequence **") inputs_)  
  ((-int-) n_sequences_)  
  #{ ((Torch::MemoryDataSet *)$p)->setInputs($inputs_  ,$n_sequences_)  ; #} 
  ())

(defmethod  torch_MemoryDataSet  setTargets (targets_  n_sequences_ )
  
  ((-gptr- "Torch::Sequence **") targets_)  
  ((-int-) n_sequences_)  
  #{ ((Torch::MemoryDataSet *)$p)->setTargets($targets_  ,$n_sequences_)  ; #} 
  ())

(defmethod  torch_MemoryDataSet  getNumberOfFrames (s  n_input_frames_  n_target_frames_ )
  
  ((-int-) s)  
  ((-gptr- "int *") n_input_frames_)  
  ((-gptr- "int *") n_target_frames_)  
  #{ ((Torch::MemoryDataSet *)$p)->getNumberOfFrames($s  ,$n_input_frames_  ,$n_target_frames_)  ; #} 
  ())

(defmethod  torch_MemoryDataSet  preProcess (pre_processing )
  
  ((-gptr- "Torch::PreProcessing *") pre_processing)  
  #{ ((Torch::MemoryDataSet *)$p)->preProcess($pre_processing)  ; #} 
  ())

(defmethod  torch_MemoryDataSet  setRealExample (s  set_inputs  set_targets )
  
  ((-int-) s)  
  ((-bool-) set_inputs)  
  ((-bool-) set_targets)  
  #{ ((Torch::MemoryDataSet *)$p)->setRealExample($s  ,$set_inputs  ,$set_targets)  ; #} 
  ())

(defmethod  torch_MemoryDataSet  pushExample ()
  
  #{ ((Torch::MemoryDataSet *)$p)->pushExample()  ; #} 
  ())

(defmethod  torch_MemoryDataSet  popExample ()
  
  #{ ((Torch::MemoryDataSet *)$p)->popExample()  ; #} 
  ())

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



;;class MemoryXFile : public XFile
(defclass  torch_MemoryXFile   torch_XFile)

(defmethod  torch_MemoryXFile  get_memory ()
  
  (gptr #{ ((Torch::MemoryXFile *)$p)->memory   #} ))        ;; MemoryXFileList *  -> gptr

(defmethod  torch_MemoryXFile  set_memory (s )
  
  ((-gptr- "Torch::MemoryXFileList *") s)  
  #{ ((Torch::MemoryXFile *)$p)->memory = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_position ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->position   #} ))

(defmethod  torch_MemoryXFile  set_position (s )
  
  ((-int-) s)  
  #{ ((Torch::MemoryXFile *)$p)->position = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_size ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->size   #} ))

(defmethod  torch_MemoryXFile  set_size (s )
  
  ((-int-) s)  
  #{ ((Torch::MemoryXFile *)$p)->size = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_total_size ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->total_size   #} ))

(defmethod  torch_MemoryXFile  set_total_size (s )
  
  ((-int-) s)  
  #{ ((Torch::MemoryXFile *)$p)->total_size = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_buffer_size ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->buffer_size   #} ))

(defmethod  torch_MemoryXFile  set_buffer_size (s )
  
  ((-int-) s)  
  #{ ((Torch::MemoryXFile *)$p)->buffer_size = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_internal_memory_node_index ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->internal_memory_node_index   #} ))

(defmethod  torch_MemoryXFile  set_internal_memory_node_index (s )
  
  ((-int-) s)  
  #{ ((Torch::MemoryXFile *)$p)->internal_memory_node_index = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_internal_position_in_the_node ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->internal_position_in_the_node   #} ))

(defmethod  torch_MemoryXFile  set_internal_position_in_the_node (s )
  
  ((-int-) s)  
  #{ ((Torch::MemoryXFile *)$p)->internal_position_in_the_node = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_buffer_format ()
  
  (gptr #{ ((Torch::MemoryXFile *)$p)->buffer_format   #} ))        ;; char *  -> gptr

(defmethod  torch_MemoryXFile  set_buffer_format (s )
  
  ((-gptr- "char *") s)  
  #{ ((Torch::MemoryXFile *)$p)->buffer_format = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  get_buffer_format_size ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->buffer_format_size   #} ))

(defmethod  torch_MemoryXFile  set_buffer_format_size (s )
  
  ((-int-) s)  
  #{ ((Torch::MemoryXFile *)$p)->buffer_format_size = $s  ; #} 
  ())

(defmethod  torch_MemoryXFile  torch_MemoryXFile ( flag buffer_format_size_ )
  ((-bool-) flag)
  
  ((-int-) buffer_format_size_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::MemoryXFile($buffer_format_size_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

;;(defmethod  torch_MemoryXFile  torch_MemoryXFile ( flag memory_  size_  buffer_format_size_ )
;;  ((-bool-) flag)
;;  
;;  ((-gptr- "Torch::MemoryXFileList *") memory_)  
;;  ((-int-) size_)  
;;  ((-int-) buffer_format_size_)  
;;  #{ if($flag == 0) {
;;            $shell_flag = 0;
;;            $p = new Torch::MemoryXFile($memory_  ,$size_  ,$buffer_format_size_); 
;;     }
;;  #} 
;;  ())

;;(defmethod  torch_MemoryXFile  torch_MemoryXFile ( flag memory_  size_  buffer_format_size_ )
;;  ((-bool-) flag)
;;  
;;  ((-gptr-) memory_)  
;;  ((-int-) size_)  
;;  ((-int-) buffer_format_size_)  
;;  #{ if($flag == 0) {
;;            $shell_flag = 0;
;;            $p = new Torch::MemoryXFile($memory_  ,$size_  ,$buffer_format_size_); 
;;     }
;;  #} 
;;  ())

(defmethod  torch_MemoryXFile  concat ()
  
  #{ ((Torch::MemoryXFile *)$p)->concat()  ; #} 
  ())

(defmethod  torch_MemoryXFile  read (ptr  block_size  n_blocks )
  
  ((-gptr-) ptr)  
  ((-int-) block_size)  
  ((-int-) n_blocks)  
  (int #{ ((Torch::MemoryXFile *)$p)->read($ptr  ,$block_size  ,$n_blocks)  #} ))

(defmethod  torch_MemoryXFile  write (ptr  block_size  n_blocks )
  
  ((-gptr-) ptr)  
  ((-int-) block_size)  
  ((-int-) n_blocks)  
  (int #{ ((Torch::MemoryXFile *)$p)->write($ptr  ,$block_size  ,$n_blocks)  #} ))

(defmethod  torch_MemoryXFile  eof ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->eof()  #} ))

(defmethod  torch_MemoryXFile  flush ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->flush()  #} ))

(defmethod  torch_MemoryXFile  seek (offset  whence )
  
  ((-int-) offset)     ;; long -> int
  ((-int-) whence)  
  (int #{ ((Torch::MemoryXFile *)$p)->seek($offset  ,$whence)  #} ))

(defmethod  torch_MemoryXFile  tell ()
  
  (int #{ ((Torch::MemoryXFile *)$p)->tell()  #} ))    ;; long -> int

(defmethod  torch_MemoryXFile  rewind ()
  
  #{ ((Torch::MemoryXFile *)$p)->rewind()  ; #} 
  ())

(defmethod  torch_MemoryXFile  scanf (format  ptr )
  
  ((-gptr- "const char *") format)  
  ((-gptr-) ptr)  
  (int #{ ((Torch::MemoryXFile *)$p)->scanf($format  ,$ptr)  #} ))

(defmethod  torch_MemoryXFile  gets (dest  size_ )
  
  ((-gptr- "char *") dest)  
  ((-int-) size_)  
  (gptr #{ ((Torch::MemoryXFile *)$p)->gets($dest  ,$size_)  #} ))        ;; char *  -> gptr

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









;;class MSEMeasurer : public Measurer
(defclass  torch_MSEMeasurer   torch_Measurer)

(defmethod  torch_MSEMeasurer  get_average_examples ()
  
  (bool #{ ((Torch::MSEMeasurer *)$p)->average_examples   #} ))

(defmethod  torch_MSEMeasurer  set_average_examples (s )
  
  ((-bool-) s)  
  #{ ((Torch::MSEMeasurer *)$p)->average_examples = $s  ; #} 
  ())

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

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

(defmethod  torch_MSEMeasurer  get_average_frames ()
  
  (bool #{ ((Torch::MSEMeasurer *)$p)->average_frames   #} ))

(defmethod  torch_MSEMeasurer  set_average_frames (s )
  
  ((-bool-) s)  
  #{ ((Torch::MSEMeasurer *)$p)->average_frames = $s  ; #} 
  ())

(defmethod  torch_MSEMeasurer  get_internal_error ()
  
  (double #{ ((Torch::MSEMeasurer *)$p)->internal_error   #} ))

(defmethod  torch_MSEMeasurer  set_internal_error (s )
  
  ((-double-) s)  
  #{ ((Torch::MSEMeasurer *)$p)->internal_error = $s  ; #} 
  ())

(defmethod  torch_MSEMeasurer  get_inputs ()
  
  (gptr #{ ((Torch::MSEMeasurer *)$p)->inputs   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_MSEMeasurer  set_inputs (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::MSEMeasurer *)$p)->inputs = $s  ; #} 
  ())

(defmethod  torch_MSEMeasurer  torch_MSEMeasurer ( flag inputs_  data_  file_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Sequence *") inputs_)  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "Torch::XFile *") file_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::MSEMeasurer($inputs_  ,$data_  ,$file_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_MSEMeasurer  reset ()
  
  #{ ((Torch::MSEMeasurer *)$p)->reset()  ; #} 
  ())

(defmethod  torch_MSEMeasurer  measureExample ()
  
  #{ ((Torch::MSEMeasurer *)$p)->measureExample()  ; #} 
  ())

(defmethod  torch_MSEMeasurer  measureIteration ()
  
  #{ ((Torch::MSEMeasurer *)$p)->measureIteration()  ; #} 
  ())

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



;;class MultiClassFormat : public ClassFormat
(defclass  torch_MultiClassFormat   torch_ClassFormat)

(defmethod  torch_MultiClassFormat  get_tabclasses ()
  
  (gptr #{ ((Torch::MultiClassFormat *)$p)->tabclasses   #} ))        ;; double *  -> gptr

(defmethod  torch_MultiClassFormat  set_tabclasses (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::MultiClassFormat *)$p)->tabclasses = $s  ; #} 
  ())

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

;;(defmethod  torch_MultiClassFormat  torch_MultiClassFormat ( flag n_classes_  class_labels_ )
;;  ((-bool-) flag)
;;  
;;  ((-int-) n_classes_)  
;;  ((-gptr- "double *") class_labels_)  
;;  #{ if($flag == 0) {
;;            $shell_flag = 0;
;;            $p = new Torch::MultiClassFormat($n_classes_  ,$class_labels_); 
;;     }
;;  #} 
;;  ())

(defmethod  torch_MultiClassFormat  getClass (vector )
  
  ((-gptr- "double *") vector)  
  (int #{ ((Torch::MultiClassFormat *)$p)->getClass($vector )  #} ))

(defmethod  torch_MultiClassFormat  getOutputSize ()
  
  (int #{ ((Torch::MultiClassFormat *)$p)->getOutputSize()  #} ))

(defmethod  torch_MultiClassFormat  fromOneHot (outputs  one_hot_outputs )
  
  ((-gptr- "double *") outputs)  
  ((-gptr- "double *") one_hot_outputs)  
  #{ ((Torch::MultiClassFormat *)$p)->fromOneHot($outputs  ,$one_hot_outputs)  ; #} 
  ())

(defmethod  torch_MultiClassFormat  toOneHot (outputs  one_hot_outputs )
  
  ((-gptr- "double *") outputs)  
  ((-gptr- "double *") one_hot_outputs)  
  #{ ((Torch::MultiClassFormat *)$p)->toOneHot($outputs  ,$one_hot_outputs)  ; #} 
  ())

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










;;class NLLMeasurer : public Measurer
(defclass  torch_NLLMeasurer   torch_Measurer)

(defmethod  torch_NLLMeasurer  get_average_examples ()
  
  (bool #{ ((Torch::NLLMeasurer *)$p)->average_examples   #} ))

(defmethod  torch_NLLMeasurer  set_average_examples (s )
  
  ((-bool-) s)  
  #{ ((Torch::NLLMeasurer *)$p)->average_examples = $s  ; #} 
  ())

(defmethod  torch_NLLMeasurer  get_average_frames ()
  
  (bool #{ ((Torch::NLLMeasurer *)$p)->average_frames   #} ))

(defmethod  torch_NLLMeasurer  set_average_frames (s )
  
  ((-bool-) s)  
  #{ ((Torch::NLLMeasurer *)$p)->average_frames = $s  ; #} 
  ())

(defmethod  torch_NLLMeasurer  get_internal_error ()
  
  (double #{ ((Torch::NLLMeasurer *)$p)->internal_error   #} ))

(defmethod  torch_NLLMeasurer  set_internal_error (s )
  
  ((-double-) s)  
  #{ ((Torch::NLLMeasurer *)$p)->internal_error = $s  ; #} 
  ())

(defmethod  torch_NLLMeasurer  get_inputs ()
  
  (gptr #{ ((Torch::NLLMeasurer *)$p)->inputs   #} ))        ;; Sequence *  -> gptr

(defmethod  torch_NLLMeasurer  set_inputs (s )
  
  ((-gptr- "Torch::Sequence *") s)  
  #{ ((Torch::NLLMeasurer *)$p)->inputs = $s  ; #} 
  ())

(defmethod  torch_NLLMeasurer  torch_NLLMeasurer ( flag inputs_  data_  file_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Sequence *") inputs_)  
  ((-gptr- "Torch::DataSet*") data_)  
  ((-gptr- "Torch::XFile *") file_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::NLLMeasurer($inputs_  ,$data_  ,$file_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_NLLMeasurer  reset ()
  
  #{ ((Torch::NLLMeasurer *)$p)->reset()  ; #} 
  ())

(defmethod  torch_NLLMeasurer  measureExample ()
  
  #{ ((Torch::NLLMeasurer *)$p)->measureExample()  ; #} 
  ())

(defmethod  torch_NLLMeasurer  measureIteration ()
  
  #{ ((Torch::NLLMeasurer *)$p)->measureIteration()  ; #} 
  ())

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



;;class NPTrainer : public Trainer
(defclass  torch_NPTrainer   torch_Trainer)

(defmethod  torch_NPTrainer  torch_NPTrainer ( flag machine_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Machine *") machine_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::NPTrainer($machine_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_NPTrainer  train (s  measurers )
  
  ((-gptr- "Torch::DataSet *") s)  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::NPTrainer *)$p)->train($s ,$measurers)  ; #} 
  ())

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



;;class NullXFile : public XFile
(defclass  torch_NullXFile   torch_XFile)

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

(defmethod  torch_NullXFile  read (ptr  block_size  n_blocks )
  
  ((-gptr-) ptr)  
  ((-int-) block_size)  
  ((-int-) n_blocks)  
  (int #{ ((Torch::NullXFile *)$p)->read($ptr  ,$block_size  ,$n_blocks)  #} ))

(defmethod  torch_NullXFile  write (ptr  block_size  n_blocks )
  
  ((-gptr-) ptr)  
  ((-int-) block_size)  
  ((-int-) n_blocks)  
  (int #{ ((Torch::NullXFile *)$p)->write($ptr  ,$block_size  ,$n_blocks)  #} ))

(defmethod  torch_NullXFile  eof ()
  
  (int #{ ((Torch::NullXFile *)$p)->eof()  #} ))

(defmethod  torch_NullXFile  flush ()
  
  (int #{ ((Torch::NullXFile *)$p)->flush()  #} ))

(defmethod  torch_NullXFile  seek (offset  whence )
  
  ((-int-) offset)   ;; long -> int
  ((-int-) whence)  
  (int #{ ((Torch::NullXFile *)$p)->seek($offset  ,$whence)  #} ))

(defmethod  torch_NullXFile  tell ()
  
  (int  #{ ((Torch::NullXFile *)$p)->tell()  #} ))       ;; long -> int

(defmethod  torch_NullXFile  rewind ()
  
  #{ ((Torch::NullXFile *)$p)->rewind()  ; #} 
  ())

(defmethod  torch_NullXFile  scanf (format  ptr )
  
  ((-gptr- "const char *") format)  
  ((-gptr-) ptr)  
  (int #{ ((Torch::NullXFile *)$p)->scanf($format  ,$ptr)  #} ))

(defmethod  torch_NullXFile  gets (dest  size_ )
  
  ((-gptr- "char *") dest)  
  ((-int-) size_)  
  (gptr #{ ((Torch::NullXFile *)$p)->gets($dest  ,$size_)  #} ))        ;; char *  -> gptr

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





;;class OneHotClassFormat : public ClassFormat
(defclass  torch_OneHotClassFormat   torch_ClassFormat)

(defmethod  torch_OneHotClassFormat  get_class_labels_buffer ()
  
  (gptr #{ ((Torch::OneHotClassFormat *)$p)->class_labels_buffer   #} ))        ;; double *  -> gptr

(defmethod  torch_OneHotClassFormat  set_class_labels_buffer (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::OneHotClassFormat *)$p)->class_labels_buffer = $s  ; #} 
  ())

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

(defmethod  torch_OneHotClassFormat  torch_OneHotClassFormat ( flag n_targets )
  ((-bool-) flag)
  
  ((-int-) n_targets)  
  #{ if($flag == 0) {
            $shell_flag = 0;
            $p = new Torch::OneHotClassFormat($n_targets); 
     }
  #} 
  ())

(defmethod  torch_OneHotClassFormat  getClass (target )
  
  ((-gptr- "double *") target)  
  (int #{ ((Torch::OneHotClassFormat *)$p)->getClass($target)  #} ))

(defmethod  torch_OneHotClassFormat  getOutputSize ()
  
  (int #{ ((Torch::OneHotClassFormat *)$p)->getOutputSize()  #} ))

(defmethod  torch_OneHotClassFormat  fromOneHot (outputs  one_hot_outputs )
  
  ((-gptr- "double *") outputs)  
  ((-gptr- "double *") one_hot_outputs)  
  #{ ((Torch::OneHotClassFormat *)$p)->fromOneHot($outputs  ,$one_hot_outputs)  ; #} 
  ())

(defmethod  torch_OneHotClassFormat  toOneHot (outputs  one_hot_outputs )
  
  ((-gptr- "double *") outputs)  
  ((-gptr- "double *") one_hot_outputs)  
  #{ ((Torch::OneHotClassFormat *)$p)->toOneHot($outputs  ,$one_hot_outputs)  ; #} 
  ())

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



;;class OutputMeasurer : public Measurer
(defclass  torch_OutputMeasurer   torch_Measurer)

(defmethod  torch_OutputMeasurer  get_sequences ()
  
  (gptr #{ ((Torch::OutputMeasurer *)$p)->sequences   #} ))        ;; SequenceList *  -> gptr

(defmethod  torch_OutputMeasurer  set_sequences (s )
  
  ((-gptr- "Torch::SequenceList *") s)  
  #{ ((Torch::OutputMeasurer *)$p)->sequences = $s  ; #} 
  ())

(defmethod  torch_OutputMeasurer  get_total_frame_size ()
  
  (int #{ ((Torch::OutputMeasurer *)$p)->total_frame_size   #} ))

(defmethod  torch_OutputMeasurer  set_total_frame_size (s )
  
  ((-int-) s)  
  #{ ((Torch::OutputMeasurer *)$p)->total_frame_size = $s  ; #} 
  ())

(defmethod  torch_OutputMeasurer  torch_OutputMeasurer ( flag data_  file_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "Torch::XFile *") file_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::OutputMeasurer($data_  ,$file_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_OutputMeasurer  addSequence (sequence )
  
  ((-gptr- "Torch::Sequence *") sequence)  
  #{ ((Torch::OutputMeasurer *)$p)->addSequence($sequence)  ; #} 
  ())

(defmethod  torch_OutputMeasurer  measureExample ()
  
  #{ ((Torch::OutputMeasurer *)$p)->measureExample()  ; #} 
  ())

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





;;class ParzenMachine : public Machine
(defclass  torch_ParzenMachine   torch_Machine)

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

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

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

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

(defmethod  torch_ParzenMachine  get_real_examples ()
  
  (gptr #{ ((Torch::ParzenMachine *)$p)->real_examples   #} ))        ;; int *  -> gptr

(defmethod  torch_ParzenMachine  set_real_examples (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::ParzenMachine *)$p)->real_examples = $s  ; #} 
  ())

(defmethod  torch_ParzenMachine  get_n_real_examples ()
  
  (int #{ ((Torch::ParzenMachine *)$p)->n_real_examples   #} ))

(defmethod  torch_ParzenMachine  set_n_real_examples (s )
  
  ((-int-) s)  
  #{ ((Torch::ParzenMachine *)$p)->n_real_examples = $s  ; #} 
  ())

(defmethod  torch_ParzenMachine  get_denominator ()
  
  (double #{ ((Torch::ParzenMachine *)$p)->denominator   #} ))

(defmethod  torch_ParzenMachine  set_denominator (s )
  
  ((-double-) s)  
  #{ ((Torch::ParzenMachine *)$p)->denominator = $s  ; #} 
  ())

(defmethod  torch_ParzenMachine  get_n_outputs ()
  
  (int #{ ((Torch::ParzenMachine *)$p)->n_outputs   #} ))

(defmethod  torch_ParzenMachine  set_n_outputs (s )
  
  ((-int-) s)  
  #{ ((Torch::ParzenMachine *)$p)->n_outputs = $s  ; #} 
  ())

(defmethod  torch_ParzenMachine  get_n_inputs ()
  
  (int #{ ((Torch::ParzenMachine *)$p)->n_inputs   #} ))

(defmethod  torch_ParzenMachine  set_n_inputs (s )
  
  ((-int-) s)  
  #{ ((Torch::ParzenMachine *)$p)->n_inputs = $s  ; #} 
  ())

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

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

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

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

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







;;class QCMachine : public Machine
(defclass  torch_QCMachine   torch_Machine)

(defmethod  torch_QCMachine  get_Cup ()
  
  (gptr #{ ((Torch::QCMachine *)$p)->Cup   #} ))        ;; double *  -> gptr

(defmethod  torch_QCMachine  set_Cup (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCMachine *)$p)->Cup = $s  ; #} 
  ())

(defmethod  torch_QCMachine  get_Cdown ()
  
  (gptr #{ ((Torch::QCMachine *)$p)->Cdown   #} ))        ;; double *  -> gptr

(defmethod  torch_QCMachine  set_Cdown (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCMachine *)$p)->Cdown = $s  ; #} 
  ())

(defmethod  torch_QCMachine  get_bound_eps ()
  
  (double #{ ((Torch::QCMachine *)$p)->bound_eps   #} ))

(defmethod  torch_QCMachine  set_bound_eps (s )
  
  ((-double-) s)  
  #{ ((Torch::QCMachine *)$p)->bound_eps = $s  ; #} 
  ())

(defmethod  torch_QCMachine  get_n_alpha ()
  
  (int #{ ((Torch::QCMachine *)$p)->n_alpha   #} ))

(defmethod  torch_QCMachine  set_n_alpha (s )
  
  ((-int-) s)  
  #{ ((Torch::QCMachine *)$p)->n_alpha = $s  ; #} 
  ())

(defmethod  torch_QCMachine  get_alpha ()
  
  (gptr #{ ((Torch::QCMachine *)$p)->alpha   #} ))        ;; double *  -> gptr

(defmethod  torch_QCMachine  set_alpha (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCMachine *)$p)->alpha = $s  ; #} 
  ())

(defmethod  torch_QCMachine  get_grad ()
  
  (gptr #{ ((Torch::QCMachine *)$p)->grad   #} ))        ;; double *  -> gptr

(defmethod  torch_QCMachine  set_grad (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCMachine *)$p)->grad = $s  ; #} 
  ())

(defmethod  torch_QCMachine  get_y ()
  
  (gptr #{ ((Torch::QCMachine *)$p)->y   #} ))        ;; double *  -> gptr

(defmethod  torch_QCMachine  set_y (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCMachine *)$p)->y = $s  ; #} 
  ())

(defmethod  torch_QCMachine  get_cache ()
  
  (gptr #{ ((Torch::QCMachine *)$p)->cache   #} ))        ;; QCCache *  -> gptr

(defmethod  torch_QCMachine  set_cache (s )
  
  ((-gptr- "Torch::QCCache *") s)  
  #{ ((Torch::QCMachine *)$p)->cache = $s  ; #} 
  ())

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

(defmethod  torch_QCMachine  reInit (n_alpha_ )
  
  ((-int-) n_alpha_)  
  #{ ((Torch::QCMachine *)$p)->reInit($n_alpha_)  ; #} 
  ())

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



;;class QCTrainer : public Trainer
(defclass  torch_QCTrainer   torch_Trainer)

(defmethod  torch_QCTrainer  get_qcmachine ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->qcmachine   #} ))        ;; QCMachine *  -> gptr

(defmethod  torch_QCTrainer  set_qcmachine (s )
  
  ((-gptr- "Torch::QCMachine *") s)  
  #{ ((Torch::QCTrainer *)$p)->qcmachine = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_cache ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->cache   #} ))        ;; QCCache *  -> gptr

(defmethod  torch_QCTrainer  set_cache (s )
  
  ((-gptr- "Torch::QCCache *") s)  
  #{ ((Torch::QCTrainer *)$p)->cache = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_n_unshrink ()
  
  (int #{ ((Torch::QCTrainer *)$p)->n_unshrink   #} ))

(defmethod  torch_QCTrainer  set_n_unshrink (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->n_unshrink = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_n_max_unshrink ()
  
  (int #{ ((Torch::QCTrainer *)$p)->n_max_unshrink   #} ))

(defmethod  torch_QCTrainer  set_n_max_unshrink (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->n_max_unshrink = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_k_xi ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->k_xi   #} ))        ;; double *  -> gptr

(defmethod  torch_QCTrainer  set_k_xi (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCTrainer *)$p)->k_xi = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_k_xj ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->k_xj   #} ))        ;; double *  -> gptr

(defmethod  torch_QCTrainer  set_k_xj (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCTrainer *)$p)->k_xj = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_old_alpha_xi ()
  
  (double #{ ((Torch::QCTrainer *)$p)->old_alpha_xi   #} ))

(defmethod  torch_QCTrainer  set_old_alpha_xi (s )
  
  ((-double-) s)  
  #{ ((Torch::QCTrainer *)$p)->old_alpha_xi = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_old_alpha_xj ()
  
  (double #{ ((Torch::QCTrainer *)$p)->old_alpha_xj   #} ))

(defmethod  torch_QCTrainer  set_old_alpha_xj (s )
  
  ((-double-) s)  
  #{ ((Torch::QCTrainer *)$p)->old_alpha_xj = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_current_error ()
  
  (double #{ ((Torch::QCTrainer *)$p)->current_error   #} ))

(defmethod  torch_QCTrainer  set_current_error (s )
  
  ((-double-) s)  
  #{ ((Torch::QCTrainer *)$p)->current_error = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_active_var_new ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->active_var_new   #} ))        ;; int *  -> gptr

(defmethod  torch_QCTrainer  set_active_var_new (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::QCTrainer *)$p)->active_var_new = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_n_active_var_new ()
  
  (int #{ ((Torch::QCTrainer *)$p)->n_active_var_new   #} ))

(defmethod  torch_QCTrainer  set_n_active_var_new (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->n_active_var_new = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_n_alpha ()
  
  (int #{ ((Torch::QCTrainer *)$p)->n_alpha   #} ))

(defmethod  torch_QCTrainer  set_n_alpha (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->n_alpha = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_deja_shrink ()
  
  (bool #{ ((Torch::QCTrainer *)$p)->deja_shrink   #} ))

(defmethod  torch_QCTrainer  set_deja_shrink (s )
  
  ((-bool-) s)  
  #{ ((Torch::QCTrainer *)$p)->deja_shrink = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_unshrink_mode ()
  
  (bool #{ ((Torch::QCTrainer *)$p)->unshrink_mode   #} ))

(defmethod  torch_QCTrainer  set_unshrink_mode (s )
  
  ((-bool-) s)  
  #{ ((Torch::QCTrainer *)$p)->unshrink_mode = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_y ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->y   #} ))        ;; double *  -> gptr

(defmethod  torch_QCTrainer  set_y (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCTrainer *)$p)->y = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_alpha ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->alpha   #} ))        ;; double *  -> gptr

(defmethod  torch_QCTrainer  set_alpha (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCTrainer *)$p)->alpha = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_grad ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->grad   #} ))        ;; double *  -> gptr

(defmethod  torch_QCTrainer  set_grad (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCTrainer *)$p)->grad = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_eps_shrink ()
  
  (double #{ ((Torch::QCTrainer *)$p)->eps_shrink   #} ))

(defmethod  torch_QCTrainer  set_eps_shrink (s )
  
  ((-double-) s)  
  #{ ((Torch::QCTrainer *)$p)->eps_shrink = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_end_eps ()
  
  (double #{ ((Torch::QCTrainer *)$p)->end_eps   #} ))

(defmethod  torch_QCTrainer  set_end_eps (s )
  
  ((-double-) s)  
  #{ ((Torch::QCTrainer *)$p)->end_eps = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_bound_eps ()
  
  (double #{ ((Torch::QCTrainer *)$p)->bound_eps   #} ))

(defmethod  torch_QCTrainer  set_bound_eps (s )
  
  ((-double-) s)  
  #{ ((Torch::QCTrainer *)$p)->bound_eps = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_n_active_var ()
  
  (int #{ ((Torch::QCTrainer *)$p)->n_active_var   #} ))

(defmethod  torch_QCTrainer  set_n_active_var (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->n_active_var = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_active_var ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->active_var   #} ))        ;; int *  -> gptr

(defmethod  torch_QCTrainer  set_active_var (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::QCTrainer *)$p)->active_var = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_not_at_bound_at_iter ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->not_at_bound_at_iter   #} ))        ;; int *  -> gptr

(defmethod  torch_QCTrainer  set_not_at_bound_at_iter (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::QCTrainer *)$p)->not_at_bound_at_iter = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_iter ()
  
  (int #{ ((Torch::QCTrainer *)$p)->iter   #} ))

(defmethod  torch_QCTrainer  set_iter (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->iter = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_n_iter_min_to_shrink ()
  
  (int #{ ((Torch::QCTrainer *)$p)->n_iter_min_to_shrink   #} ))

(defmethod  torch_QCTrainer  set_n_iter_min_to_shrink (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->n_iter_min_to_shrink = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_n_iter_message ()
  
  (int #{ ((Torch::QCTrainer *)$p)->n_iter_message   #} ))

(defmethod  torch_QCTrainer  set_n_iter_message (s )
  
  ((-int-) s)  
  #{ ((Torch::QCTrainer *)$p)->n_iter_message = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_status_alpha ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->status_alpha   #} ))        ;; char *  -> gptr

(defmethod  torch_QCTrainer  set_status_alpha (s )
  
  ((-gptr- "char *") s)  
  #{ ((Torch::QCTrainer *)$p)->status_alpha = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_Cup ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->Cup   #} ))        ;; double *  -> gptr

(defmethod  torch_QCTrainer  set_Cup (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCTrainer *)$p)->Cup = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  get_Cdown ()
  
  (gptr #{ ((Torch::QCTrainer *)$p)->Cdown   #} ))        ;; double *  -> gptr

(defmethod  torch_QCTrainer  set_Cdown (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::QCTrainer *)$p)->Cdown = $s  ; #} 
  ())

(defmethod  torch_QCTrainer  torch_QCTrainer ( flag qcmachine_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::QCMachine *") qcmachine_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::QCTrainer($qcmachine_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_QCTrainer  train (data  measurers )
  
  ((-gptr- "Torch::DataSet *") data)  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::QCTrainer *)$p)->train($data  ,$measurers)  ; #} 
  ())

(defmethod  torch_QCTrainer  prepareToLaunch ()
  
  #{ ((Torch::QCTrainer *)$p)->prepareToLaunch()  ; #} 
  ())

(defmethod  torch_QCTrainer  atomiseAll ()
  
  #{ ((Torch::QCTrainer *)$p)->atomiseAll()  ; #} 
  ())

(defmethod  torch_QCTrainer  bCompute ()
  
  (bool #{ ((Torch::QCTrainer *)$p)->bCompute()  #} ))

(defmethod  torch_QCTrainer  selectVariables (i  j )
  
  ((-gptr- "int *") i)  
  ((-gptr- "int *") j)  
  (bool #{ ((Torch::QCTrainer *)$p)->selectVariables($i  ,$j)  #} ))

(defmethod  torch_QCTrainer  checkShrinking (bmin  bmax )
  
  ((-double-) bmin)  
  ((-double-) bmax)  
  (int #{ ((Torch::QCTrainer *)$p)->checkShrinking($bmin  ,$bmax)  #} ))

(defmethod  torch_QCTrainer  shrink ()
  
  #{ ((Torch::QCTrainer *)$p)->shrink()  ; #} 
  ())

(defmethod  torch_QCTrainer  unShrink ()
  
  #{ ((Torch::QCTrainer *)$p)->unShrink()  ; #} 
  ())

(defmethod  torch_QCTrainer  analyticSolve (xi  xj )
  
  ((-int-) xi)  
  ((-int-) xj)  
  #{ ((Torch::QCTrainer *)$p)->analyticSolve($xi  ,$xj)  ; #} 
  ())

(defmethod  torch_QCTrainer  updateStatus (i )
  
  ((-int-) i)  
  #{ ((Torch::QCTrainer *)$p)->updateStatus($i)  ; #} 
  ())

(defmethod  torch_QCTrainer  isNotUp (i )
  
  ((-int-) i)  
  (bool #{ ((Torch::QCTrainer *)$p)->isNotUp($i)  #} ))

(defmethod  torch_QCTrainer  isNotDown (i )
  
  ((-int-) i)  
  (bool #{ ((Torch::QCTrainer *)$p)->isNotDown($i)  #} ))

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





;;class SaturationMeasurer : public Measurer
(defclass  torch_SaturationMeasurer   torch_Measurer)

(defmethod  torch_SaturationMeasurer  get_derivatives_sum ()
  
  (double #{ ((Torch::SaturationMeasurer *)$p)->derivatives_sum   #} ))

(defmethod  torch_SaturationMeasurer  set_derivatives_sum (s )
  
  ((-double-) s)  
  #{ ((Torch::SaturationMeasurer *)$p)->derivatives_sum = $s  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  get_outputs_sum ()
  
  (double #{ ((Torch::SaturationMeasurer *)$p)->outputs_sum   #} ))

(defmethod  torch_SaturationMeasurer  set_outputs_sum (s )
  
  ((-double-) s)  
  #{ ((Torch::SaturationMeasurer *)$p)->outputs_sum = $s  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  get_n_sum_out ()
  
  (double #{ ((Torch::SaturationMeasurer *)$p)->n_sum_out   #} ))

(defmethod  torch_SaturationMeasurer  set_n_sum_out (s )
  
  ((-double-) s)  
  #{ ((Torch::SaturationMeasurer *)$p)->n_sum_out = $s  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  get_n_sum_der ()
  
  (double #{ ((Torch::SaturationMeasurer *)$p)->n_sum_der   #} ))

(defmethod  torch_SaturationMeasurer  set_n_sum_der (s )
  
  ((-double-) s)  
  #{ ((Torch::SaturationMeasurer *)$p)->n_sum_der = $s  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  get_machine ()
  
  (gptr #{ ((Torch::SaturationMeasurer *)$p)->machine   #} ))        ;; GradientMachine *  -> gptr

(defmethod  torch_SaturationMeasurer  set_machine (s )
  
  ((-gptr- "Torch::GradientMachine *") s)  
  #{ ((Torch::SaturationMeasurer *)$p)->machine = $s  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  torch_SaturationMeasurer ( flag machine_  data_  file_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::GradientMachine *") machine_)  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "Torch::XFile *") file_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::SaturationMeasurer($machine_  ,$data_  ,$file_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_SaturationMeasurer  reset ()
  
  #{ ((Torch::SaturationMeasurer *)$p)->reset()  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  reset_ ()
  
  #{ ((Torch::SaturationMeasurer *)$p)->reset_()  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  measureExample ()
  
  #{ ((Torch::SaturationMeasurer *)$p)->measureExample()  ; #} 
  ())

(defmethod  torch_SaturationMeasurer  measureIteration ()
  
  #{ ((Torch::SaturationMeasurer *)$p)->measureIteration()  ; #} 
  ())

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












;;class StochasticGradient : public Trainer
(defclass  torch_StochasticGradient   torch_Trainer)

(defmethod  torch_StochasticGradient  get_criterion ()
  
  (gptr #{ ((Torch::StochasticGradient *)$p)->criterion   #} ))        ;; Criterion *  -> gptr

(defmethod  torch_StochasticGradient  set_criterion (s )
  
  ((-gptr- "Torch::Criterion *") s)  
  #{ ((Torch::StochasticGradient *)$p)->criterion = $s  ; #} 
  ())

(defmethod  torch_StochasticGradient  get_learning_rate ()
  
  (double #{ ((Torch::StochasticGradient *)$p)->learning_rate   #} ))

(defmethod  torch_StochasticGradient  set_learning_rate (s )
  
  ((-double-) s)  
  #{ ((Torch::StochasticGradient *)$p)->learning_rate = $s  ; #} 
  ())

(defmethod  torch_StochasticGradient  get_learning_rate_decay ()
  
  (double #{ ((Torch::StochasticGradient *)$p)->learning_rate_decay   #} ))

(defmethod  torch_StochasticGradient  set_learning_rate_decay (s )
  
  ((-double-) s)  
  #{ ((Torch::StochasticGradient *)$p)->learning_rate_decay = $s  ; #} 
  ())

(defmethod  torch_StochasticGradient  get_end_accuracy ()
  
  (double #{ ((Torch::StochasticGradient *)$p)->end_accuracy   #} ))

(defmethod  torch_StochasticGradient  set_end_accuracy (s )
  
  ((-double-) s)  
  #{ ((Torch::StochasticGradient *)$p)->end_accuracy = $s  ; #} 
  ())

(defmethod  torch_StochasticGradient  get_max_iter ()
  
  (int #{ ((Torch::StochasticGradient *)$p)->max_iter   #} ))

(defmethod  torch_StochasticGradient  set_max_iter (s )
  
  ((-int-) s)  
  #{ ((Torch::StochasticGradient *)$p)->max_iter = $s  ; #} 
  ())

(defmethod  torch_StochasticGradient  get_do_shuffle ()
  
  (bool #{ ((Torch::StochasticGradient *)$p)->do_shuffle   #} ))

(defmethod  torch_StochasticGradient  set_do_shuffle (s )
  
  ((-bool-) s)  
  #{ ((Torch::StochasticGradient *)$p)->do_shuffle = $s  ; #} 
  ())

(defmethod  torch_StochasticGradient  torch_StochasticGradient ( flag machine_  criterion_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::GradientMachine *") machine_)  
  ((-gptr- "Torch::Criterion *") criterion_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::StochasticGradient($machine_  ,$criterion_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_StochasticGradient  train (data  measurers )
  
  ((-gptr- "Torch::DataSet *") data)  
  ((-gptr- "Torch::MeasurerList *") measurers)  
  #{ ((Torch::StochasticGradient *)$p)->train($data  ,$measurers)  ; #} 
  ())

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




;;class SVMCache : public QCCache
(defclass  torch_SVMCache   torch_QCCache)

(defmethod  torch_SVMCache  get_n_alpha ()
  
  (int #{ ((Torch::SVMCache *)$p)->n_alpha   #} ))

(defmethod  torch_SVMCache  set_n_alpha (s )
  
  ((-int-) s)  
  #{ ((Torch::SVMCache *)$p)->n_alpha = $s  ; #} 
  ())

(defmethod  torch_SVMCache  get_n_cache_entries ()
  
  (int #{ ((Torch::SVMCache *)$p)->n_cache_entries   #} ))

(defmethod  torch_SVMCache  set_n_cache_entries (s )
  
  ((-int-) s)  
  #{ ((Torch::SVMCache *)$p)->n_cache_entries = $s  ; #} 
  ())

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

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

(defmethod  torch_SVMCache  get_memory_cache ()
  
  (gptr #{ ((Torch::SVMCache *)$p)->memory_cache   #} ))        ;; double *  -> gptr

(defmethod  torch_SVMCache  set_memory_cache (s )
  
  ((-gptr- "double *") s)  
  #{ ((Torch::SVMCache *)$p)->memory_cache = $s  ; #} 
  ())

(defmethod  torch_SVMCache  get_cached ()
  
  (gptr #{ ((Torch::SVMCache *)$p)->cached   #} ))        ;; SVMCacheList *  -> gptr

(defmethod  torch_SVMCache  set_cached (s )
  
  ((-gptr- "Torch::SVMCacheList *") s)  
  #{ ((Torch::SVMCache *)$p)->cached = $s  ; #} 
  ())

(defmethod  torch_SVMCache  get_list_index ()
  
  (gptr #{ ((Torch::SVMCache *)$p)->list_index   #} ))        ;; SVMCacheList **  -> gptr

(defmethod  torch_SVMCache  set_list_index (s )
  
  ((-gptr- "Torch::SVMCacheList **") s)  
  #{ ((Torch::SVMCache *)$p)->list_index = $s  ; #} 
  ())

(defmethod  torch_SVMCache  get_kernel ()
  
  (gptr #{ ((Torch::SVMCache *)$p)->kernel   #} ))        ;; Kernel *  -> gptr

(defmethod  torch_SVMCache  set_kernel (s )
  
  ((-gptr- "Torch::Kernel *") s)  
  #{ ((Torch::SVMCache *)$p)->kernel = $s  ; #} 
  ())

(defmethod  torch_SVMCache  get_n_active_var ()
  
  (int #{ ((Torch::SVMCache *)$p)->n_active_var   #} ))

(defmethod  torch_SVMCache  set_n_active_var (s )
  
  ((-int-) s)  
  #{ ((Torch::SVMCache *)$p)->n_active_var = $s  ; #} 
  ())

(defmethod  torch_SVMCache  get_active_var ()
  
  (gptr #{ ((Torch::SVMCache *)$p)->active_var   #} ))        ;; int *  -> gptr

(defmethod  torch_SVMCache  set_active_var (s )
  
  ((-gptr- "int *") s)  
  #{ ((Torch::SVMCache *)$p)->active_var = $s  ; #} 
  ())

(defmethod  torch_SVMCache  get_temp_allocator ()
  
  (gptr #{ ((Torch::SVMCache *)$p)->temp_allocator   #} ))        ;; Allocator *  -> gptr

(defmethod  torch_SVMCache  set_temp_allocator (s )
  
  ((-gptr- "Torch::Allocator *") s)  
  #{ ((Torch::SVMCache *)$p)->temp_allocator = $s  ; #} 
  ())

(defmethod  torch_SVMCache  torch_SVMCache ( flag n_alpha_  kernel_  cache_size_in_megs_ )
  ((-bool-) flag)
  
  ((-int-) n_alpha_)  
  ((-gptr- "Torch::Kernel *") kernel_)  
  ((-double-) cache_size_in_megs_)  
;;  #{ if($flag == false) {
;;            $shell_flag = false;
;;            $p = new Torch::SVMCache($n_alpha_  ,$kernel_  ,$cache_size_in_megs_); 
;;     }
;;     else
;;            $shell_flag = true; 
;;  #} 
  ())

(defmethod  torch_SVMCache  allocate ()
  
  #{ ((Torch::SVMCache *)$p)->allocate()  ; #} 
  ())

(defmethod  torch_SVMCache  clear ()
  
  #{ ((Torch::SVMCache *)$p)->clear()  ; #} 
  ())

(defmethod  torch_SVMCache  destroy ()
  
  #{ ((Torch::SVMCache *)$p)->destroy()  ; #} 
  ())

(defmethod  torch_SVMCache  setActiveVariables (active_var_  n_active_var_ )
  
  ((-gptr- "int *") active_var_)  
  ((-int-) n_active_var_)  
  #{ ((Torch::SVMCache *)$p)->setActiveVariables($active_var_  ,$n_active_var_)  ; #} 
  ())

(defmethod  torch_SVMCache  adressCache (index )
  
  ((-int-) index)  
  (gptr #{ ((Torch::SVMCache *)$p)->adressCache($index)  #} ))        ;; double *  -> gptr

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


















;;class TimeMeasurer : public Measurer
(defclass  torch_TimeMeasurer   torch_Measurer)

(defmethod  torch_TimeMeasurer  get_timer ()
  
  (gptr #{ ((Torch::TimeMeasurer *)$p)->timer   #} ))        ;; Timer *  -> gptr

(defmethod  torch_TimeMeasurer  set_timer (s )
  
  ((-gptr- "Torch::Timer *") s)  
  #{ ((Torch::TimeMeasurer *)$p)->timer = $s  ; #} 
  ())

(defmethod  torch_TimeMeasurer  torch_TimeMeasurer ( flag data_  file_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::DataSet *") data_)  
  ((-gptr- "Torch::XFile *") file_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::TimeMeasurer($data_  ,$file_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

(defmethod  torch_TimeMeasurer  reset ()
  
  #{ ((Torch::TimeMeasurer *)$p)->reset()  ; #} 
  ())

(defmethod  torch_TimeMeasurer  measureIteration ()
  
  #{ ((Torch::TimeMeasurer *)$p)->measureIteration()  ; #} 
  ())

(defmethod  torch_TimeMeasurer  measureEnd ()
  
  #{ ((Torch::TimeMeasurer *)$p)->measureEnd()  ; #} 
  ())

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





;;class TwoClassFormat : public ClassFormat
(defclass  torch_TwoClassFormat   torch_ClassFormat)

(defmethod  torch_TwoClassFormat  get_tabclasses (i  )
  
  
  ((-int-) i)
  (double #{ ((Torch::TwoClassFormat *)$p)->tabclasses[$i]   #} ))

(defmethod  torch_TwoClassFormat  set_tabclasses (s  i )
  
  ((-double-) s)  
  ((-int-) i)  
  #{ ((Torch::TwoClassFormat *)$p)->tabclasses[$i] = $s ; #} 
  ())

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

;;(defmethod  torch_TwoClassFormat  torch_TwoClassFormat ( flag class_1  class_2 )
;;  ((-bool-) flag)
;;  
;;  ((-double-) class_1)  
;;  ((-double-) class_2)  
;;  #{ if($flag == 0) {
;;            $shell_flag = 0;
;;            $p = new Torch::TwoClassFormat($class_1  ,$class_2); 
;;     }
;;  #} 
;;  ())

(defmethod  torch_TwoClassFormat  getClass (vector )
  
  ((-gptr- "double *") vector)  
  (int #{ ((Torch::TwoClassFormat *)$p)->getClass($vector)  #} ))

(defmethod  torch_TwoClassFormat  getOutputSize ()
  
  (int #{ ((Torch::TwoClassFormat *)$p)->getOutputSize()  #} ))

(defmethod  torch_TwoClassFormat  fromOneHot (outputs  one_hot_outputs )
  
  ((-gptr- "double *") outputs)  
  ((-gptr- "double *") one_hot_outputs)  
  #{ ((Torch::TwoClassFormat *)$p)->fromOneHot($outputs  ,$one_hot_outputs)  ; #} 
  ())

(defmethod  torch_TwoClassFormat  toOneHot (outputs  one_hot_outputs )
  
  ((-gptr- "double *") outputs)  
  ((-gptr- "double *") one_hot_outputs)  
  #{ ((Torch::TwoClassFormat *)$p)->toOneHot($outputs  ,$one_hot_outputs)  ; #} 
  ())

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







;;class WeightedSumMachine : public Machine
(defclass  torch_WeightedSumMachine   torch_Machine)

(defmethod  torch_WeightedSumMachine  get_n_outputs ()
  
  (int #{ ((Torch::WeightedSumMachine *)$p)->n_outputs   #} ))

(defmethod  torch_WeightedSumMachine  set_n_outputs (s )
  
  ((-int-) s)  
  #{ ((Torch::WeightedSumMachine *)$p)->n_outputs = $s  ; #} 
  ())

(defmethod  torch_WeightedSumMachine  get_trainers ()
  
  (gptr #{ ((Torch::WeightedSumMachine *)$p)->trainers   #} ))        ;; Trainer **  -> gptr

(defmethod  torch_WeightedSumMachine  set_trainers (s )
  
  ((-gptr- "Torch::Trainer **") s)  
  #{ ((Torch::WeightedSumMachine *)$p)->trainers = $s  ; #} 
  ())

(defmethod  torch_WeightedSumMachine  get_trainers_measurers ()
  
  (gptr #{ ((Torch::WeightedSumMachine *)$p)->trainers_measurers   #} ))        ;; MeasurerList **  -> gptr

(defmethod  torch_WeightedSumMachine  set_trainers_measurers (s )
  
  ((-gptr- "Torch::MeasurerList **") s)  
  #{ ((Torch::WeightedSumMachine *)$p)->trainers_measurers = $s  ; #} 
  ())

(defmethod  torch_WeightedSumMachine  get_n_trainers ()
  
  (int #{ ((Torch::WeightedSumMachine *)$p)->n_trainers   #} ))

(defmethod  torch_WeightedSumMachine  set_n_trainers (s )
  
  ((-int-) s)  
  #{ ((Torch::WeightedSumMachine *)$p)->n_trainers = $s  ; #} 
  ())

(defmethod  torch_WeightedSumMachine  get_n_trainers_trained ()
  
  (int #{ ((Torch::WeightedSumMachine *)$p)->n_trainers_trained   #} ))

(defmethod  torch_WeightedSumMachine  set_n_trainers_trained (s )
  
  ((-int-) s)  
  #{ ((Torch::WeightedSumMachine *)$p)->n_trainers_trained = $s  ; #} 
  ())

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

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

(defmethod  torch_WeightedSumMachine  get_weights_is_allocated ()
  
  (bool #{ ((Torch::WeightedSumMachine *)$p)->weights_is_allocated   #} ))

(defmethod  torch_WeightedSumMachine  set_weights_is_allocated (s )
  
  ((-bool-) s)  
  #{ ((Torch::WeightedSumMachine *)$p)->weights_is_allocated = $s  ; #} 
  ())

(defmethod  torch_WeightedSumMachine  torch_WeightedSumMachine ( flag trainer_  n_trainers_  trainers_measurers  weights_ )
  ((-bool-) flag)
  
  ((-gptr- "Torch::Trainer **") trainer_)  
  ((-int-) n_trainers_)  
  ((-gptr- "Torch::MeasurerList **") trainers_measurers)  
  ((-gptr- "double *") weights_)  
  #{ if($flag == false) {
            $shell_flag = false;
            $p = new Torch::WeightedSumMachine($trainer_  ,$n_trainers_  ,$trainers_measurers  ,$weights_); 
     }
     else
            $shell_flag = true; 
  #} 
  ())

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

(defmethod  torch_WeightedSumMachine  reset ()
  
  #{ ((Torch::WeightedSumMachine *)$p)->reset()  ; #} 
  ())

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

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

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


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

(dhc-make-with-c++ () (list torch-libtorch) 
  dummy_level2
  (torch_bagging  -destructor  train  bootstrapdata  torch_bagging  set_is_selected_examples  get_is_selected_examples  set_n_unselected_examples  get_n_unselected_examples  set_selected_examples  get_selected_examples  set_unselected_examples  get_unselected_examples  set_n_trainers  get_n_trainers  set_w_machine  get_w_machine)
  (torch_gradientmachine  -destructor  savexfile  loadxfile  framebackward  frameforward  setpartialbackprop  backward  forward  iterinitialize  torch_gradientmachine  set_beta  get_beta  set_der_params  get_der_params  set_params  get_params  set_n_outputs  get_n_outputs  set_n_inputs  get_n_inputs  set_partial_backprop  get_partial_backprop)
  (torch_bayesclassifier  train  -destructor  torch_bayesclassifier  set_classes_n  get_classes_n  set_classes  get_classes  set_n_classes  get_n_classes  set_bayesmachine  get_bayesmachine)
  (torch_bayesclassifiermachine  savexfile  loadxfile  reset  forward  -destructor  torch_bayesclassifiermachine  set_trainers_measurers  get_trainers_measurers  set_class_format  get_class_format  set_allocated_log_priors  get_allocated_log_priors  set_log_probabilities  get_log_probabilities  set_log_priors  get_log_priors  set_trainers  get_trainers  set_n_outputs  get_n_outputs  set_n_trainers  get_n_trainers)
  (torch_boosting  -destructor  train  torch_boosting  set_weights  get_weights  set_n_trainers  get_n_trainers  set_class_format  get_class_format  set_w_machine  get_w_machine)
;; method decleared but not defined: init_
  (torch_boostingmeasurer  -destructor  measureiteration  measureexample  reset   setinputs  setweights  setdataset  torch_boostingmeasurer  set_class_format  get_class_format  set_current_example  get_current_example  set_internal_error  get_internal_error  set_status  get_status  set_beta  get_beta  set_weights  get_weights  set_inputs  get_inputs)
  (torch_classformatdataset  -destructor  popexample  pushexample  preprocess  setrealexample  getnumberofframes  torch_classformatdataset  set_class_labels  get_class_labels  set_data  get_data)
  (torch_classmeasurer  -destructor  reset_  init_  measureend  measureiteration  measureexample  reset  printconfusionmatrix  torch_classmeasurer  set_n_classes  get_n_classes  set_calc_confusion_at_each_iter  get_calc_confusion_at_each_iter  set_calc_confusion  get_calc_confusion  set_class_format  get_class_format  set_inputs  get_inputs  set_confusion  get_confusion  set_internal_error  get_internal_error)
  (torch_classnllmeasurer  -destructor  measureiteration  measureexample  reset  torch_classnllmeasurer  set_inputs  get_inputs  set_internal_error  get_internal_error  set_average_frames  get_average_frames  set_average_examples  get_average_examples  set_class_format  get_class_format)
;; method needs to be added and fixed: init
  (torch_diskdataset  -destructor  popexample  pushexample  setrealexample  preprocess  getnumberofframes  torch_diskdataset  set_io_targets  get_io_targets  set_io_inputs  get_io_inputs  set_pre_processes  get_pre_processes)
  (torch_diskxfile  -destructor  gets  scanf  rewind  tell  seek  flush  eof  write  read  setbigendianmode  setlittleendianmode  setnativemode  isnativemode  isbigendianprocessor  islittleendianprocessor  torch_diskxfile  set_its_a_pipe  get_its_a_pipe  set_is_opened  get_is_opened  set_file  get_file)
  (torch_emtrainer  -destructor  decode  test  train  torch_emtrainer  set_viterbi  get_viterbi  set_max_iter  get_max_iter  set_end_accuracy  get_end_accuracy  set_distribution  get_distribution)
  (torch_exampleframeselectordataset  -destructor  preprocess  popexample  pushexample  setrealexample  getnumberofframes  removeexample  addexample  torch_exampleframeselectordataset  set_target_frames_indices  get_target_frames_indices  set_input_frames_indices  get_input_frames_indices  set_n_selected_target_frames  get_n_selected_target_frames  set_n_selected_input_frames  get_n_selected_input_frames  set_data  get_data)
  (torch_frameselectordataset  -destructor  popexample  pushexample  setrealexample  getnumberofframes  preprocess  unselecttargetframes  unselectinputframes  selecttargetframes  selectinputframes  torch_frameselectordataset  set_target_frames_indices  get_target_frames_indices  set_input_frames_indices  get_input_frames_indices  set_n_selected_target_frames  get_n_selected_target_frames  set_n_selected_input_frames  get_n_selected_input_frames  set_data  get_data)
  (torch_ioascii  -destructor  gettotalnumberofframes  getnumberofframes  getsequence  savesequence  torch_ioascii  set_max_load  get_max_load  set_filename  get_filename  set_n_total_frames  get_n_total_frames  set_one_file_is_one_sequence  get_one_file_is_one_sequence)
  (torch_iobin  -destructor  gettotalnumberofframes  getnumberofframes  getsequence  savesequence  torch_iobin  set_is_sequential  get_is_sequential  set_max_load  get_max_load  set_filename  get_filename  set_n_total_frames  get_n_total_frames  set_one_file_is_one_sequence  get_one_file_is_one_sequence)
  (torch_iobufferize  -destructor  gettotalnumberofframes  getnumberofframes  getsequence  bufferizesequence  torch_iobufferize  set_bufferized_sequence_index  get_bufferized_sequence_index  set_bufferized_sequence  get_bufferized_sequence  set_io_torch  get_io_torch)
  (torch_iohtk  hasvq  haszeroc  haszerom  hascrcc  hascompx  hasnulle  hasaccs  hasdelta  hasenergy  baseparmkind  str2parmkind  parmkind2str  -destructor  gettotalnumberofframes  getnumberofframes  getsequence  savesequence  torch_iohtk  set_header  get_header  set_is_sequential  get_is_sequential  set_max_load  get_max_load  set_filename  get_filename  set_n_total_frames  get_n_total_frames  set_one_file_is_one_sequence  get_one_file_is_one_sequence)
  (torch_iohtktarget  -destructor  gettotalnumberofframes  getnumberofframes  getsequence  savesequence  torch_iohtktarget  set_words  get_words  set_lexicon  get_lexicon  set_n_per_frame  get_n_per_frame  set_max_load  get_max_load  set_filename  get_filename  set_n_total_frames  get_n_total_frames  set_one_file_is_one_sequence  get_one_file_is_one_sequence)
  (torch_iomulti  -destructor  gettotalnumberofframes  getnumberofframes  getsequence  torch_iomulti  set_offsets  get_offsets  set_indices  get_indices  set_n_files  get_n_files  set_io_files  get_io_files)
  (torch_iosub  -destructor  gettotalnumberofframes  getnumberofframes  getsequence  torch_iosub  set_offset  get_offset  set_io_torch  get_io_torch)
  (torch_dotkernel  -destructor  eval  torch_dotkernel  set_s  get_s)
  (torch_polynomialkernel  -destructor  eval  torch_polynomialkernel  set_r  get_r  set_s  get_s  set_d  get_d)
  (torch_gaussiankernel  -destructor  eval  torch_gaussiankernel  set_g  get_g)
  (torch_sigmoidkernel  -destructor  eval  torch_sigmoidkernel  set_r  get_r  set_s  get_s)
  (torch_knn  -destructor  setk  setdataset  forward  torch_knn  set_n_real_examples  get_n_real_examples  set_real_examples  get_real_examples  set_n_outputs  get_n_outputs  set_data  get_data  set_indices  get_indices  set_distances  get_distances  set_k  get_k)
  (torch_meanvarnorm  -destructor  savexfile  loadxfile  preprocesstargets  preprocessinputs  torch_meanvarnorm  set_targets_stdv  get_targets_stdv  set_inputs_stdv  get_inputs_stdv  set_targets_mean  get_targets_mean  set_inputs_mean  get_inputs_mean  set_n_targets  get_n_targets  set_n_inputs  get_n_inputs)
;; method needs to be added and fixed: init
  (torch_memorydataset  -destructor  popexample  pushexample  setrealexample  preprocess  getnumberofframes  settargets  setinputs  torch_memorydataset  set_targets_array  get_targets_array  set_inputs_array  get_inputs_array)
  (torch_memoryxfile  -destructor  gets  scanf  rewind  tell  seek  flush  eof  write  read  concat  torch_memoryxfile  set_buffer_format_size  get_buffer_format_size  set_buffer_format  get_buffer_format  set_internal_position_in_the_node  get_internal_position_in_the_node  set_internal_memory_node_index  get_internal_memory_node_index  set_buffer_size  get_buffer_size  set_total_size  get_total_size  set_size  get_size  set_position  get_position  set_memory  get_memory)
  (torch_msemeasurer  -destructor  measureiteration  measureexample  reset  torch_msemeasurer  set_inputs  get_inputs  set_internal_error  get_internal_error  set_average_frames  get_average_frames  set_average_frame_size  get_average_frame_size  set_average_examples  get_average_examples)
  (torch_multiclassformat  -destructor  toonehot  fromonehot  getoutputsize  getclass  torch_multiclassformat  set_tabclasses  get_tabclasses)
  (torch_nllmeasurer  -destructor  measureiteration  measureexample  reset  torch_nllmeasurer  set_inputs  get_inputs  set_internal_error  get_internal_error  set_average_frames  get_average_frames  set_average_examples  get_average_examples)
  (torch_nptrainer  -destructor  train  torch_nptrainer)
  (torch_nullxfile  -destructor  gets  scanf  rewind  tell  seek  flush  eof  write  read  torch_nullxfile)
  (torch_onehotclassformat  -destructor  toonehot  fromonehot  getoutputsize  getclass  torch_onehotclassformat  set_class_labels_buffer  get_class_labels_buffer)
  (torch_outputmeasurer  -destructor  measureexample  addsequence  torch_outputmeasurer  set_total_frame_size  get_total_frame_size  set_sequences  get_sequences)
  (torch_parzenmachine  -destructor  setvar  setdataset  forward  torch_parzenmachine  set_n_inputs  get_n_inputs  set_n_outputs  get_n_outputs  set_denominator  get_denominator  set_n_real_examples  get_n_real_examples  set_real_examples  get_real_examples  set_data  get_data  set_var  get_var)
  (torch_qcmachine  -destructor  reinit  torch_qcmachine  set_cache  get_cache  set_y  get_y  set_grad  get_grad  set_alpha  get_alpha  set_n_alpha  get_n_alpha  set_bound_eps  get_bound_eps  set_cdown  get_cdown  set_cup  get_cup)
;; method decleared but not defined: bcompute
  (torch_qctrainer  -destructor  isnotdown  isnotup  updatestatus  analyticsolve  unshrink  shrink  checkshrinking  selectvariables  atomiseall  preparetolaunch  train  torch_qctrainer  set_cdown  get_cdown  set_cup  get_cup  set_status_alpha  get_status_alpha  set_n_iter_message  get_n_iter_message  set_n_iter_min_to_shrink  get_n_iter_min_to_shrink  set_iter  get_iter  set_not_at_bound_at_iter  get_not_at_bound_at_iter  set_active_var  get_active_var  set_n_active_var  get_n_active_var  set_bound_eps  get_bound_eps  set_end_eps  get_end_eps  set_eps_shrink  get_eps_shrink  set_grad  get_grad  set_alpha  get_alpha  set_y  get_y  set_unshrink_mode  get_unshrink_mode  set_deja_shrink  get_deja_shrink  set_n_alpha  get_n_alpha  set_n_active_var_new  get_n_active_var_new  set_active_var_new  get_active_var_new  set_current_error  get_current_error  set_old_alpha_xj  get_old_alpha_xj  set_old_alpha_xi  get_old_alpha_xi  set_k_xj  get_k_xj  set_k_xi  get_k_xi  set_n_max_unshrink  get_n_max_unshrink  set_n_unshrink  get_n_unshrink  set_cache  get_cache  set_qcmachine  get_qcmachine)
  (torch_saturationmeasurer  -destructor  measureiteration  measureexample  reset_  reset  torch_saturationmeasurer  set_machine  get_machine  set_n_sum_der  get_n_sum_der  set_n_sum_out  get_n_sum_out  set_outputs_sum  get_outputs_sum  set_derivatives_sum  get_derivatives_sum)
  (torch_stochasticgradient  -destructor  train  torch_stochasticgradient  set_do_shuffle  get_do_shuffle  set_max_iter  get_max_iter  set_end_accuracy  get_end_accuracy  set_learning_rate_decay  get_learning_rate_decay  set_learning_rate  get_learning_rate  set_criterion  get_criterion)
  (torch_svmcache  -destructor  adresscache  setactivevariables  destroy  clear  allocate  torch_svmcache  set_temp_allocator  get_temp_allocator  set_active_var  get_active_var  set_n_active_var  get_n_active_var  set_kernel  get_kernel  set_list_index  get_list_index  set_cached  get_cached  set_memory_cache  get_memory_cache  set_cache_size_in_megs  get_cache_size_in_megs  set_n_cache_entries  get_n_cache_entries  set_n_alpha  get_n_alpha)
  (torch_timemeasurer  -destructor  measureend  measureiteration  reset  torch_timemeasurer  set_timer  get_timer)
  (torch_twoclassformat  -destructor  toonehot  fromonehot  getoutputsize  getclass  torch_twoclassformat  set_tabclasses  get_tabclasses)
  (torch_weightedsummachine  -destructor  savexfile  loadxfile  reset  forward  torch_weightedsummachine  set_weights_is_allocated  get_weights_is_allocated  set_weights  get_weights  set_n_trainers_trained  get_n_trainers_trained  set_n_trainers  get_n_trainers  set_trainers_measurers  get_trainers_measurers  set_trainers  get_trainers  set_n_outputs  get_n_outputs)
)
