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



#? *** alloc

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

#? * (dummy_alloc)
#? * (alloc_torch_allocatornode)
#? * (memsize_torch_allocatornode)
#? * (get_ptr_torch_allocatornode <s>)
#? * (set_ptr_torch_allocatornode <s> <tval>)
#? * (get_object_style_torch_allocatornode <s>)
#? * (set_object_style_torch_allocatornode <s> <tval>)
#? * (get_prev_torch_allocatornode <s>)
#? * (set_prev_torch_allocatornode <s> <tval>)
#? * (get_next_torch_allocatornode <s>)
#? * (set_next_torch_allocatornode <s> <tval>)
#? * (alloc_torch_cmdoption)
#? * (memsize_torch_cmdoption)
#? * (get_name_torch_cmdoption <s>)
#? * (set_name_torch_cmdoption <s> <tval>)
#? * (get_help_torch_cmdoption <s>)
#? * (set_help_torch_cmdoption <s> <tval>)
#? * (get_ptr_torch_cmdoption <s>)
#? * (set_ptr_torch_cmdoption <s> <tval>)
#? * (get_type_torch_cmdoption <s>)
#? * (set_type_torch_cmdoption <s> <tval>)
#? * (get_status_torch_cmdoption <s>)
#? * (set_status_torch_cmdoption <s> <tval>)
#? * (get_save_torch_cmdoption <s>)
#? * (set_save_torch_cmdoption <s> <tval>)
#? * (get_is_setted_torch_cmdoption <s>)
#? * (set_is_setted_torch_cmdoption <s> <tval>)
#? * (get_init_value_torch_cmdoption <s>)
#? * (set_init_value_torch_cmdoption <s> <tval>)
#? * (alloc_torch_connectednode)
#? * (memsize_torch_connectednode)
#? * (get_machine_torch_connectednode <s>)
#? * (set_machine_torch_connectednode <s> <tval>)
#? * (get_input_links_torch_connectednode <s>)
#? * (set_input_links_torch_connectednode <s> <tval>)
#? * (get_alpha_links_torch_connectednode <s>)
#? * (set_alpha_links_torch_connectednode <s> <tval>)
#? * (get_alpha_links_offset_torch_connectednode <s>)
#? * (set_alpha_links_offset_torch_connectednode <s> <tval>)
#? * (get_n_input_links_torch_connectednode <s>)
#? * (set_n_input_links_torch_connectednode <s> <tval>)
#? * (get_n_alpha_links_torch_connectednode <s>)
#? * (set_n_alpha_links_torch_connectednode <s> <tval>)
#? * (get_n_inputs_check_torch_connectednode <s>)
#? * (set_n_inputs_check_torch_connectednode <s> <tval>)
#? * (get_inputs_torch_connectednode <s>)
#? * (set_inputs_torch_connectednode <s> <tval>)
#? * (get_alpha_torch_connectednode <s>)
#? * (set_alpha_torch_connectednode <s> <tval>)
#? * (alloc_torch_framesubsets)
#? * (memsize_torch_framesubsets)
#? * (get_subsets_torch_framesubsets <s>)
#? * (set_subsets_torch_framesubsets <s> <tval>)
#? * (get_subsets_sizes_torch_framesubsets <s>)
#? * (set_subsets_sizes_torch_framesubsets <s> <tval>)
#? * (get_n_subsets_torch_framesubsets <s>)
#? * (set_n_subsets_torch_framesubsets <s> <tval>)
#? * (get_n_selected_frames_torch_framesubsets <s>)
#? * (set_n_selected_frames_torch_framesubsets <s> <tval>)
#? * (get_selected_frames_torch_framesubsets <s>)
#? * (set_selected_frames_torch_framesubsets <s> <tval>)
#? * (alloc_torch_internalamoi)
#? * (memsize_torch_internalamoi)
#? * (get_data_index_torch_internalamoi <s>)
#? * (set_data_index_torch_internalamoi <s> <tval>)
#? * (get_start_inputs_frame_torch_internalamoi <s>)
#? * (set_start_inputs_frame_torch_internalamoi <s> <tval>)
#? * (get_start_targets_frame_torch_internalamoi <s>)
#? * (set_start_targets_frame_torch_internalamoi <s> <tval>)
#? * (get_n_selected_inputs_frames_torch_internalamoi <s>)
#? * (set_n_selected_inputs_frames_torch_internalamoi <s> <tval>)
#? * (get_n_selected_targets_frames_torch_internalamoi <s>)
#? * (set_n_selected_targets_frames_torch_internalamoi <s> <tval>)
#? * (alloc_torch_htkheader)
#? * (memsize_torch_htkheader)
#? * (get_n_samples_torch_htkheader <s>)
#? * (set_n_samples_torch_htkheader <s> <tval>)
#? * (get_sample_period_torch_htkheader <s>)
#? * (set_sample_period_torch_htkheader <s> <tval>)
#? * (get_sample_size_torch_htkheader <s>)
#? * (set_sample_size_torch_htkheader <s> <tval>)
#? * (get_sample_kind_torch_htkheader <s>)
#? * (set_sample_kind_torch_htkheader <s> <tval>)
#? * (alloc_torch_memoryxfilenode)
#? * (memsize_torch_memoryxfilenode)
#? * (get_mem_torch_memoryxfilenode <s>)
#? * (set_mem_torch_memoryxfilenode <s> <tval>)
#? * (get_size_torch_memoryxfilenode <s>)
#? * (set_size_torch_memoryxfilenode <s> <tval>)
#? * (alloc_torch_option)
#? * (memsize_torch_option)
#? * (get_name_torch_option <s>)
#? * (set_name_torch_option <s> <tval>)
#? * (get_help_torch_option <s>)
#? * (set_help_torch_option <s> <tval>)
#? * (get_size_torch_option <s>)
#? * (set_size_torch_option <s> <tval>)
#? * (get_ptr_torch_option <s>)
#? * (set_ptr_torch_option <s> <tval>)
#? * (alloc_torch_stacknode)
#? * (memsize_torch_stacknode)
#? * (get_address_torch_stacknode <s>)
#? * (set_address_torch_stacknode <s> <tval>)
#? * (get_ptr_torch_stacknode <s>)
#? * (set_ptr_torch_stacknode <s> <tval>)
#? * (get_size_torch_stacknode <s>)
#? * (set_size_torch_stacknode <s> <tval>)
#? * (alloc_torch_svmcachelist)
#? * (memsize_torch_svmcachelist)
#? * (get_adr_torch_svmcachelist <s>)
#? * (set_adr_torch_svmcachelist <s> <tval>)
#? * (get_index_torch_svmcachelist <s>)
#? * (set_index_torch_svmcachelist <s> <tval>)
#? * (get_prev_torch_svmcachelist <s>)
#? * (set_prev_torch_svmcachelist <s> <tval>)
#? * (get_next_torch_svmcachelist <s>)
#? * (set_next_torch_svmcachelist <s> <tval>)

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


;; struct AllocatorNode
(de alloc_torch_AllocatorNode ()
  (gptr #{ malloc(sizeof(Torch::AllocatorNode)) #} ))

(de memsize_torch_AllocatorNode ()
  (int #{ sizeof(Torch::AllocatorNode)  #} ))

(de get_ptr_torch_AllocatorNode ( s )
  ((-gptr- "Torch::AllocatorNode *") s)
  (gptr #{ $s->ptr  #} )) ;; void *  -> gptr

(de set_ptr_torch_AllocatorNode ( s tval)
  ((-gptr- "Torch::AllocatorNode *") s)
  ((-gptr-) tval)
 #{ $s->ptr = $tval;  #} 
  ())

(de get_object_style_torch_AllocatorNode ( s )
  ((-gptr- "Torch::AllocatorNode *") s)
  (int #{ $s->object_style  #} ))

(de set_object_style_torch_AllocatorNode ( s tval)
  ((-gptr- "Torch::AllocatorNode *") s)
  ((-int-) tval)
 #{ $s->object_style = $tval;  #} 
  ())

(de get_prev_torch_AllocatorNode ( s )
  ((-gptr- "Torch::AllocatorNode *") s)
  (gptr #{ $s->prev  #} )) ;; AllocatorNode *  -> gptr

(de set_prev_torch_AllocatorNode ( s tval)
  ((-gptr- "Torch::AllocatorNode *") s)
  ((-gptr- "Torch::AllocatorNode *") tval)
 #{ $s->prev = $tval;  #} 
  ())

(de get_next_torch_AllocatorNode ( s )
  ((-gptr- "Torch::AllocatorNode *") s)
  (gptr #{ $s->next  #} )) ;; AllocatorNode *  -> gptr

(de set_next_torch_AllocatorNode ( s tval)
  ((-gptr- "Torch::AllocatorNode *") s)
  ((-gptr- "Torch::AllocatorNode *") tval)
 #{ $s->next = $tval;  #} 
  ())



 


;; struct ConnectedNode
(de alloc_torch_ConnectedNode ()
  (gptr #{ malloc(sizeof(Torch::ConnectedNode)) #} ))

(de memsize_torch_ConnectedNode ()
  (int #{ sizeof(Torch::ConnectedNode)  #} ))

(de get_machine_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (gptr #{ $s->machine  #} )) ;; GradientMachine *  -> gptr

(de set_machine_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-gptr- "Torch::GradientMachine *") tval)
 #{ $s->machine = $tval;  #} 
  ())

(de get_input_links_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (gptr #{ $s->input_links  #} )) ;; Sequence **  -> gptr

(de set_input_links_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-gptr- "Torch::Sequence **") tval)
 #{ $s->input_links = $tval;  #} 
  ())

(de get_alpha_links_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (gptr #{ $s->alpha_links  #} )) ;; Sequence **  -> gptr

(de set_alpha_links_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-gptr- "Torch::Sequence **") tval)
 #{ $s->alpha_links = $tval;  #} 
  ())

(de get_alpha_links_offset_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (gptr #{ $s->alpha_links_offset  #} )) ;; int *  -> gptr

(de set_alpha_links_offset_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-gptr- "int *") tval)
 #{ $s->alpha_links_offset = $tval;  #} 
  ())

(de get_n_input_links_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (int #{ $s->n_input_links  #} ))

(de set_n_input_links_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-int-) tval)
 #{ $s->n_input_links = $tval;  #} 
  ())

(de get_n_alpha_links_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (int #{ $s->n_alpha_links  #} ))

(de set_n_alpha_links_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-int-) tval)
 #{ $s->n_alpha_links = $tval;  #} 
  ())

(de get_n_inputs_check_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (int #{ $s->n_inputs_check  #} ))

(de set_n_inputs_check_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-int-) tval)
 #{ $s->n_inputs_check = $tval;  #} 
  ())

(de get_inputs_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (gptr #{ $s->inputs  #} )) ;; Sequence *  -> gptr

(de set_inputs_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-gptr- "Torch::Sequence *") tval)
 #{ $s->inputs = $tval;  #} 
  ())

(de get_alpha_torch_ConnectedNode ( s )
  ((-gptr- "Torch::ConnectedNode *") s)
  (gptr #{ $s->alpha  #} )) ;; Sequence *  -> gptr

(de set_alpha_torch_ConnectedNode ( s tval)
  ((-gptr- "Torch::ConnectedNode *") s)
  ((-gptr- "Torch::Sequence *") tval)
 #{ $s->alpha = $tval;  #} 
  ())




;; struct FrameSubsets
(de alloc_torch_FrameSubsets ()
  (gptr #{ malloc(sizeof(Torch::FrameSubsets)) #} ))

(de memsize_torch_FrameSubsets ()
  (int #{ sizeof(Torch::FrameSubsets)  #} ))

(de get_subsets_torch_FrameSubsets ( s )
  ((-gptr- "Torch::FrameSubsets *") s)
  (gptr #{ $s->subsets  #} )) ;; int **  -> gptr

(de set_subsets_torch_FrameSubsets ( s tval)
  ((-gptr- "Torch::FrameSubsets *") s)
  ((-gptr- "int **") tval)
 #{ $s->subsets = $tval;  #} 
  ())

(de get_subsets_sizes_torch_FrameSubsets ( s )
  ((-gptr- "Torch::FrameSubsets *") s)
  (gptr #{ $s->subsets_sizes  #} )) ;; int *  -> gptr

(de set_subsets_sizes_torch_FrameSubsets ( s tval)
  ((-gptr- "Torch::FrameSubsets *") s)
  ((-gptr- "int *") tval)
 #{ $s->subsets_sizes = $tval;  #} 
  ())

(de get_n_subsets_torch_FrameSubsets ( s )
  ((-gptr- "Torch::FrameSubsets *") s)
  (int #{ $s->n_subsets  #} ))

(de set_n_subsets_torch_FrameSubsets ( s tval)
  ((-gptr- "Torch::FrameSubsets *") s)
  ((-int-) tval)
 #{ $s->n_subsets = $tval;  #} 
  ())

(de get_n_selected_frames_torch_FrameSubsets ( s )
  ((-gptr- "Torch::FrameSubsets *") s)
  (int #{ $s->n_selected_frames  #} ))

(de set_n_selected_frames_torch_FrameSubsets ( s tval)
  ((-gptr- "Torch::FrameSubsets *") s)
  ((-int-) tval)
 #{ $s->n_selected_frames = $tval;  #} 
  ())

(de get_selected_frames_torch_FrameSubsets ( s )
  ((-gptr- "Torch::FrameSubsets *") s)
  (gptr #{ $s->selected_frames  #} )) ;; int *  -> gptr

(de set_selected_frames_torch_FrameSubsets ( s tval)
  ((-gptr- "Torch::FrameSubsets *") s)
  ((-gptr- "int *") tval)
 #{ $s->selected_frames = $tval;  #} 
  ())



;; struct InternalAMoi
(de alloc_torch_InternalAMoi ()
  (gptr #{ malloc(sizeof(Torch::InternalAMoi)) #} ))

(de memsize_torch_InternalAMoi ()
  (int #{ sizeof(Torch::InternalAMoi)  #} ))

(de get_data_index_torch_InternalAMoi ( s )
  ((-gptr- "Torch::InternalAMoi *") s)
  (int #{ $s->data_index  #} ))

(de set_data_index_torch_InternalAMoi ( s tval)
  ((-gptr- "Torch::InternalAMoi *") s)
  ((-int-) tval)
 #{ $s->data_index = $tval;  #} 
  ())

(de get_start_inputs_frame_torch_InternalAMoi ( s )
  ((-gptr- "Torch::InternalAMoi *") s)
  (int #{ $s->start_inputs_frame  #} ))

(de set_start_inputs_frame_torch_InternalAMoi ( s tval)
  ((-gptr- "Torch::InternalAMoi *") s)
  ((-int-) tval)
 #{ $s->start_inputs_frame = $tval;  #} 
  ())

(de get_start_targets_frame_torch_InternalAMoi ( s )
  ((-gptr- "Torch::InternalAMoi *") s)
  (int #{ $s->start_targets_frame  #} ))

(de set_start_targets_frame_torch_InternalAMoi ( s tval)
  ((-gptr- "Torch::InternalAMoi *") s)
  ((-int-) tval)
 #{ $s->start_targets_frame = $tval;  #} 
  ())

(de get_n_selected_inputs_frames_torch_InternalAMoi ( s )
  ((-gptr- "Torch::InternalAMoi *") s)
  (int #{ $s->n_selected_inputs_frames  #} ))

(de set_n_selected_inputs_frames_torch_InternalAMoi ( s tval)
  ((-gptr- "Torch::InternalAMoi *") s)
  ((-int-) tval)
 #{ $s->n_selected_inputs_frames = $tval;  #} 
  ())

(de get_n_selected_targets_frames_torch_InternalAMoi ( s )
  ((-gptr- "Torch::InternalAMoi *") s)
  (int #{ $s->n_selected_targets_frames  #} ))

(de set_n_selected_targets_frames_torch_InternalAMoi ( s tval)
  ((-gptr- "Torch::InternalAMoi *") s)
  ((-int-) tval)
 #{ $s->n_selected_targets_frames = $tval;  #} 
  ())



;; struct HTKHeader               
(de alloc_torch_HTKHeader ()
  (gptr #{ malloc(sizeof(Torch::HTKHeader)) #} ))

(de memsize_torch_HTKHeader ()
  (int #{ sizeof(Torch::HTKHeader)  #} ))

(de get_n_samples_torch_HTKHeader ( s )
  ((-gptr- "Torch::HTKHeader *") s)
  (int #{ $s->n_samples  #} ))             ;; long -> int

(de set_n_samples_torch_HTKHeader ( s tval)
  ((-gptr- "Torch::HTKHeader *") s)
  ((-int-) tval)                           ;; long -> int
 #{ $s->n_samples = $tval;  #} 
  ())

(de get_sample_period_torch_HTKHeader ( s )
  ((-gptr- "Torch::HTKHeader *") s)
  (int #{ $s->sample_period  #} ))          ;; long -> int

(de set_sample_period_torch_HTKHeader ( s tval)
  ((-gptr- "Torch::HTKHeader *") s)
  ((-int-) tval)                             ;; long -> int
 #{ $s->sample_period = $tval;  #} 
  ())

(de get_sample_size_torch_HTKHeader ( s )
  ((-gptr- "Torch::HTKHeader *") s)
  (int #{ $s->sample_size  #} ))       ;; short -> int

(de set_sample_size_torch_HTKHeader ( s tval)
  ((-gptr- "Torch::HTKHeader *") s)
  ((-int-) tval)
 #{ $s->sample_size = $tval;  #} 
  ())

(de get_sample_kind_torch_HTKHeader ( s )
  ((-gptr- "Torch::HTKHeader *") s)
  (int #{ $s->sample_kind  #} ))         ;; short -> int

(de set_sample_kind_torch_HTKHeader ( s tval)
  ((-gptr- "Torch::HTKHeader *") s)
  ((-int-) tval)                      ;; short -> int
 #{ $s->sample_kind = $tval;  #} 
  ())




;; struct MemoryXFileNode
(de alloc_torch_MemoryXFileNode ()
  (gptr #{ malloc(sizeof(Torch::MemoryXFileNode)) #} ))

(de memsize_torch_MemoryXFileNode ()
  (int #{ sizeof(Torch::MemoryXFileNode)  #} ))

(de get_mem_torch_MemoryXFileNode ( s )
  ((-gptr- "Torch::MemoryXFileNode *") s)
  (gptr #{ $s->mem  #} )) ;; void *  -> gptr

(de set_mem_torch_MemoryXFileNode ( s tval)
  ((-gptr- "Torch::MemoryXFileNode *") s)
  ((-gptr-) tval)
 #{ $s->mem = $tval;  #} 
  ())

(de get_size_torch_MemoryXFileNode ( s )
  ((-gptr- "Torch::MemoryXFileNode *") s)
  (int #{ $s->size  #} ))

(de set_size_torch_MemoryXFileNode ( s tval)
  ((-gptr- "Torch::MemoryXFileNode *") s)
  ((-int-) tval)
 #{ $s->size = $tval;  #} 
  ())



;; struct Option
(de alloc_torch_Option ()
  (gptr #{ malloc(sizeof(Torch::Option)) #} ))

(de memsize_torch_Option ()
  (int #{ sizeof(Torch::Option)  #} ))

(de get_name_torch_Option ( s )
  ((-gptr- "Torch::Option *") s)
  (gptr #{ $s->name  #} )) ;; char *  -> gptr

(de set_name_torch_Option ( s tval)
  ((-gptr- "Torch::Option *") s)
  ((-gptr- "char *") tval)
 #{ $s->name = $tval;  #} 
  ())

(de get_help_torch_Option ( s )
  ((-gptr- "Torch::Option *") s)
  (gptr #{ $s->help  #} )) ;; char *  -> gptr

(de set_help_torch_Option ( s tval)
  ((-gptr- "Torch::Option *") s)
  ((-gptr- "char *") tval)
 #{ $s->help = $tval;  #} 
  ())

(de get_size_torch_Option ( s )
  ((-gptr- "Torch::Option *") s)
  (int #{ $s->size  #} ))

(de set_size_torch_Option ( s tval)
  ((-gptr- "Torch::Option *") s)
  ((-int-) tval)
 #{ $s->size = $tval;  #} 
  ())

(de get_ptr_torch_Option ( s )
  ((-gptr- "Torch::Option *") s)
  (gptr #{ $s->ptr  #} )) ;; void *  -> gptr

(de set_ptr_torch_Option ( s tval)
  ((-gptr- "Torch::Option *") s)
  ((-gptr-) tval)
 #{ $s->ptr = $tval;  #} 
  ())




;; struct StackNode
(de alloc_torch_StackNode ()
  (gptr #{ malloc(sizeof(Torch::StackNode)) #} ))

(de memsize_torch_StackNode ()
  (int #{ sizeof(Torch::StackNode)  #} ))

(de get_address_torch_StackNode ( s )
  ((-gptr- "Torch::StackNode *") s)
  (gptr #{ $s->address  #} )) ;; void *  -> gptr

(de set_address_torch_StackNode ( s tval)
  ((-gptr- "Torch::StackNode *") s)
  ((-gptr-) tval)
 #{ $s->address = $tval;  #} 
  ())

(de get_ptr_torch_StackNode ( s )
  ((-gptr- "Torch::StackNode *") s)
  (gptr #{ $s->ptr  #} )) ;; void *  -> gptr

(de set_ptr_torch_StackNode ( s tval)
  ((-gptr- "Torch::StackNode *") s)
  ((-gptr-) tval)
 #{ $s->ptr = $tval;  #} 
  ())

(de get_size_torch_StackNode ( s )
  ((-gptr- "Torch::StackNode *") s)
  (int #{ $s->size  #} ))

(de set_size_torch_StackNode ( s tval)
  ((-gptr- "Torch::StackNode *") s)
  ((-int-) tval)
 #{ $s->size = $tval;  #} 
  ())




;; struct SVMCacheList
(de alloc_torch_SVMCacheList ()
  (gptr #{ malloc(sizeof(Torch::SVMCacheList)) #} ))

(de memsize_torch_SVMCacheList ()
  (int #{ sizeof(Torch::SVMCacheList)  #} ))

(de get_adr_torch_SVMCacheList ( s )
  ((-gptr- "Torch::SVMCacheList *") s)
  (gptr #{ $s->adr  #} )) ;; real *  -> gptr

(de set_adr_torch_SVMCacheList ( s tval)
  ((-gptr- "Torch::SVMCacheList *") s)
  ((-gptr- "double *") tval)
 #{ $s->adr = $tval;  #} 
  ())

(de get_index_torch_SVMCacheList ( s )
  ((-gptr- "Torch::SVMCacheList *") s)
  (int #{ $s->index  #} ))

(de set_index_torch_SVMCacheList ( s tval)
  ((-gptr- "Torch::SVMCacheList *") s)
  ((-int-) tval)
 #{ $s->index = $tval;  #} 
  ())

(de get_prev_torch_SVMCacheList ( s )
  ((-gptr- "Torch::SVMCacheList *") s)
  (gptr #{ $s->prev  #} )) ;; SVMCacheList *  -> gptr

(de set_prev_torch_SVMCacheList ( s tval)
  ((-gptr- "Torch::SVMCacheList *") s)
  ((-gptr- "Torch::SVMCacheList *") tval)
 #{ $s->prev = $tval;  #} 
  ())

(de get_next_torch_SVMCacheList ( s )
  ((-gptr- "Torch::SVMCacheList *") s)
  (gptr #{ $s->next  #} )) ;; SVMCacheList *  -> gptr

(de set_next_torch_SVMCacheList ( s tval)
  ((-gptr- "Torch::SVMCacheList *") s)
  ((-gptr- "Torch::SVMCacheList *") tval)
 #{ $s->next = $tval;  #} 
  ())



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

(dhc-make-with-c++ () (list torch-libtorch) 
  dummy_alloc
  alloc_torch_allocatornode
  memsize_torch_allocatornode
  get_ptr_torch_allocatornode
  set_ptr_torch_allocatornode
  get_object_style_torch_allocatornode
  set_object_style_torch_allocatornode
  get_prev_torch_allocatornode
  set_prev_torch_allocatornode
  get_next_torch_allocatornode
  set_next_torch_allocatornode
  alloc_torch_connectednode
  memsize_torch_connectednode
  get_machine_torch_connectednode
  set_machine_torch_connectednode
  get_input_links_torch_connectednode
  set_input_links_torch_connectednode
  get_alpha_links_torch_connectednode
  set_alpha_links_torch_connectednode
  get_alpha_links_offset_torch_connectednode
  set_alpha_links_offset_torch_connectednode
  get_n_input_links_torch_connectednode
  set_n_input_links_torch_connectednode
  get_n_alpha_links_torch_connectednode
  set_n_alpha_links_torch_connectednode
  get_n_inputs_check_torch_connectednode
  set_n_inputs_check_torch_connectednode
  get_inputs_torch_connectednode
  set_inputs_torch_connectednode
  get_alpha_torch_connectednode
  set_alpha_torch_connectednode
;;  alloc_torch_framesubsets
;;  memsize_torch_framesubsets
;;  get_subsets_torch_framesubsets
;;  set_subsets_torch_framesubsets
;;  get_subsets_sizes_torch_framesubsets
;;  set_subsets_sizes_torch_framesubsets
;;  get_n_subsets_torch_framesubsets
;;  set_n_subsets_torch_framesubsets
;;  get_n_selected_frames_torch_framesubsets
;;  set_n_selected_frames_torch_framesubsets
;;  get_selected_frames_torch_framesubsets
;;  set_selected_frames_torch_framesubsets
  alloc_torch_internalamoi
  memsize_torch_internalamoi
  get_data_index_torch_internalamoi
  set_data_index_torch_internalamoi
  get_start_inputs_frame_torch_internalamoi
  set_start_inputs_frame_torch_internalamoi
  get_start_targets_frame_torch_internalamoi
  set_start_targets_frame_torch_internalamoi
  get_n_selected_inputs_frames_torch_internalamoi
  set_n_selected_inputs_frames_torch_internalamoi
  get_n_selected_targets_frames_torch_internalamoi
  set_n_selected_targets_frames_torch_internalamoi
  alloc_torch_htkheader
  memsize_torch_htkheader
  get_n_samples_torch_htkheader
  set_n_samples_torch_htkheader
  get_sample_period_torch_htkheader
  set_sample_period_torch_htkheader
  get_sample_size_torch_htkheader
  set_sample_size_torch_htkheader
  get_sample_kind_torch_htkheader
  set_sample_kind_torch_htkheader
  alloc_torch_memoryxfilenode
  memsize_torch_memoryxfilenode
  get_mem_torch_memoryxfilenode
  set_mem_torch_memoryxfilenode
  get_size_torch_memoryxfilenode
  set_size_torch_memoryxfilenode
  alloc_torch_option
  memsize_torch_option
  get_name_torch_option
  set_name_torch_option
  get_help_torch_option
  set_help_torch_option
  get_size_torch_option
  set_size_torch_option
  get_ptr_torch_option
  set_ptr_torch_option
  alloc_torch_stacknode
  memsize_torch_stacknode
  get_address_torch_stacknode
  set_address_torch_stacknode
  get_ptr_torch_stacknode
  set_ptr_torch_stacknode
  get_size_torch_stacknode
  set_size_torch_stacknode
  alloc_torch_svmcachelist
  memsize_torch_svmcachelist
  get_adr_torch_svmcachelist
  set_adr_torch_svmcachelist
  get_index_torch_svmcachelist
  set_index_torch_svmcachelist
  get_prev_torch_svmcachelist
  set_prev_torch_svmcachelist
  get_next_torch_svmcachelist
  set_next_torch_svmcachelist
)
