remove extern , add include, cleaning , ...
Allan CORNET [Tue, 23 Jun 2009 11:48:17 +0000 (13:48 +0200)]
328 files changed:
scilab/modules/scicos/Makefile.am
scilab/modules/scicos/includes/scicos_math.h [new file with mode: 0644]
scilab/modules/scicos/src/c/scicos.c
scilab/modules/scicos/src/c/scicos.vcproj
scilab/modules/scicos_blocks/Makefile.am
scilab/modules/scicos_blocks/includes/scicos_block.h
scilab/modules/scicos_blocks/includes/scicos_block4.h
scilab/modules/scicos_blocks/includes/scoMisc.h
scilab/modules/scicos_blocks/src/c/DllmainScicos_blocks.c
scilab/modules/scicos_blocks/src/c/absblk.c
scilab/modules/scicos_blocks/src/c/absolute_value.c
scilab/modules/scicos_blocks/src/c/acos_blk.c
scilab/modules/scicos_blocks/src/c/acosh_blk.c
scilab/modules/scicos_blocks/src/c/affich.c
scilab/modules/scicos_blocks/src/c/andlog.c
scilab/modules/scicos_blocks/src/c/asin_blk.c
scilab/modules/scicos_blocks/src/c/asinh_blk.c
scilab/modules/scicos_blocks/src/c/assignment.c
scilab/modules/scicos_blocks/src/c/atan_blk.c
scilab/modules/scicos_blocks/src/c/atanh_blk.c
scilab/modules/scicos_blocks/src/c/automat.c
scilab/modules/scicos_blocks/src/c/backlash.c
scilab/modules/scicos_blocks/src/c/bidon.c
scilab/modules/scicos_blocks/src/c/bit_clear_16.c
scilab/modules/scicos_blocks/src/c/bit_clear_32.c
scilab/modules/scicos_blocks/src/c/bit_clear_8.c
scilab/modules/scicos_blocks/src/c/bit_set_16.c
scilab/modules/scicos_blocks/src/c/bit_set_32.c
scilab/modules/scicos_blocks/src/c/bit_set_8.c
scilab/modules/scicos_blocks/src/c/bounce_ball.c
scilab/modules/scicos_blocks/src/c/bouncexy.c
scilab/modules/scicos_blocks/src/c/canimxy.c
scilab/modules/scicos_blocks/src/c/canimxy3d.c
scilab/modules/scicos_blocks/src/c/cdummy.c
scilab/modules/scicos_blocks/src/c/cevscpe.c
scilab/modules/scicos_blocks/src/c/cfscope.c
scilab/modules/scicos_blocks/src/c/cmat3d.c
scilab/modules/scicos_blocks/src/c/cmatview.c
scilab/modules/scicos_blocks/src/c/cmscope.c
scilab/modules/scicos_blocks/src/c/constraint_c.c
scilab/modules/scicos_blocks/src/c/convert.c
scilab/modules/scicos_blocks/src/c/cos_blk.c
scilab/modules/scicos_blocks/src/c/cosblk.c
scilab/modules/scicos_blocks/src/c/cosh_blk.c
scilab/modules/scicos_blocks/src/c/counter.c
scilab/modules/scicos_blocks/src/c/cscope.c
scilab/modules/scicos_blocks/src/c/cscopxy.c
scilab/modules/scicos_blocks/src/c/cscopxy3d.c
scilab/modules/scicos_blocks/src/c/csslti4.c
scilab/modules/scicos_blocks/src/c/cstblk4.c
scilab/modules/scicos_blocks/src/c/cstblk4_m.c
scilab/modules/scicos_blocks/src/c/cumsum_c.c
scilab/modules/scicos_blocks/src/c/cumsum_m.c
scilab/modules/scicos_blocks/src/c/cumsum_r.c
scilab/modules/scicos_blocks/src/c/cumsumz_c.c
scilab/modules/scicos_blocks/src/c/cumsumz_m.c
scilab/modules/scicos_blocks/src/c/cumsumz_r.c
scilab/modules/scicos_blocks/src/c/curve_c.c
scilab/modules/scicos_blocks/src/c/dband.c
scilab/modules/scicos_blocks/src/c/deadband.c
scilab/modules/scicos_blocks/src/c/delay4.c
scilab/modules/scicos_blocks/src/c/delay4_i16.c
scilab/modules/scicos_blocks/src/c/delay4_i32.c
scilab/modules/scicos_blocks/src/c/delay4_i8.c
scilab/modules/scicos_blocks/src/c/delay4_ui16.c
scilab/modules/scicos_blocks/src/c/delay4_ui32.c
scilab/modules/scicos_blocks/src/c/delay4_ui8.c
scilab/modules/scicos_blocks/src/c/deriv.c
scilab/modules/scicos_blocks/src/c/diffblk_c.c
scilab/modules/scicos_blocks/src/c/dmmul.c
scilab/modules/scicos_blocks/src/c/dmmul1.c
scilab/modules/scicos_blocks/src/c/dollar4.c
scilab/modules/scicos_blocks/src/c/dollar4_m.c
scilab/modules/scicos_blocks/src/c/dsslti4.c
scilab/modules/scicos_blocks/src/c/edgetrig.c
scilab/modules/scicos_blocks/src/c/evaluate_expr.c
scilab/modules/scicos_blocks/src/c/evtdly4.c
scilab/modules/scicos_blocks/src/c/evtvardly.c
scilab/modules/scicos_blocks/src/c/expblk_m.c
scilab/modules/scicos_blocks/src/c/extdiag.c
scilab/modules/scicos_blocks/src/c/extdiagz.c
scilab/modules/scicos_blocks/src/c/extract.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_LH.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_LSB.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_MSB0.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_MSB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_RB0.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_RB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_UH0.c
scilab/modules/scicos_blocks/src/c/extract_bit_16_UH1.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_LH.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_LSB.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_MSB0.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_MSB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_RB0.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_RB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_UH0.c
scilab/modules/scicos_blocks/src/c/extract_bit_32_UH1.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_LH.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_LSB.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_MSB0.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_MSB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_RB0.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_RB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_UH0.c
scilab/modules/scicos_blocks/src/c/extract_bit_8_UH1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u16_MSB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u16_RB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u16_UH1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u32_MSB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u32_RB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u32_UH1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u8_MSB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u8_RB1.c
scilab/modules/scicos_blocks/src/c/extract_bit_u8_UH1.c
scilab/modules/scicos_blocks/src/c/extractor.c
scilab/modules/scicos_blocks/src/c/extractz.c
scilab/modules/scicos_blocks/src/c/exttril.c
scilab/modules/scicos_blocks/src/c/exttrilz.c
scilab/modules/scicos_blocks/src/c/exttriu.c
scilab/modules/scicos_blocks/src/c/exttriuz.c
scilab/modules/scicos_blocks/src/c/foriterator.c
scilab/modules/scicos_blocks/src/c/fromws_c.c
scilab/modules/scicos_blocks/src/c/gain.c
scilab/modules/scicos_blocks/src/c/gainblk.c
scilab/modules/scicos_blocks/src/c/gainblk_i16e.c
scilab/modules/scicos_blocks/src/c/gainblk_i16n.c
scilab/modules/scicos_blocks/src/c/gainblk_i16s.c
scilab/modules/scicos_blocks/src/c/gainblk_i32e.c
scilab/modules/scicos_blocks/src/c/gainblk_i32n.c
scilab/modules/scicos_blocks/src/c/gainblk_i32s.c
scilab/modules/scicos_blocks/src/c/gainblk_i8e.c
scilab/modules/scicos_blocks/src/c/gainblk_i8n.c
scilab/modules/scicos_blocks/src/c/gainblk_i8s.c
scilab/modules/scicos_blocks/src/c/gainblk_ui16e.c
scilab/modules/scicos_blocks/src/c/gainblk_ui16n.c
scilab/modules/scicos_blocks/src/c/gainblk_ui16s.c
scilab/modules/scicos_blocks/src/c/gainblk_ui32e.c
scilab/modules/scicos_blocks/src/c/gainblk_ui32n.c
scilab/modules/scicos_blocks/src/c/gainblk_ui32s.c
scilab/modules/scicos_blocks/src/c/gainblk_ui8e.c
scilab/modules/scicos_blocks/src/c/gainblk_ui8n.c
scilab/modules/scicos_blocks/src/c/gainblk_ui8s.c
scilab/modules/scicos_blocks/src/c/hystheresis.c
scilab/modules/scicos_blocks/src/c/integral_func.c
scilab/modules/scicos_blocks/src/c/integralz_func.c
scilab/modules/scicos_blocks/src/c/invblk4.c
scilab/modules/scicos_blocks/src/c/logic.c
scilab/modules/scicos_blocks/src/c/logicalop.c
scilab/modules/scicos_blocks/src/c/logicalop_i16.c
scilab/modules/scicos_blocks/src/c/logicalop_i32.c
scilab/modules/scicos_blocks/src/c/logicalop_i8.c
scilab/modules/scicos_blocks/src/c/logicalop_m.c
scilab/modules/scicos_blocks/src/c/logicalop_ui16.c
scilab/modules/scicos_blocks/src/c/logicalop_ui32.c
scilab/modules/scicos_blocks/src/c/logicalop_ui8.c
scilab/modules/scicos_blocks/src/c/lookup2d.c
scilab/modules/scicos_blocks/src/c/lookup_c.c
scilab/modules/scicos_blocks/src/c/m_frequ.c
scilab/modules/scicos_blocks/src/c/mat_bksl.c
scilab/modules/scicos_blocks/src/c/mat_cath.c
scilab/modules/scicos_blocks/src/c/mat_catv.c
scilab/modules/scicos_blocks/src/c/mat_det.c
scilab/modules/scicos_blocks/src/c/mat_diag.c
scilab/modules/scicos_blocks/src/c/mat_div.c
scilab/modules/scicos_blocks/src/c/mat_expm.c
scilab/modules/scicos_blocks/src/c/mat_inv.c
scilab/modules/scicos_blocks/src/c/mat_lu.c
scilab/modules/scicos_blocks/src/c/mat_pinv.c
scilab/modules/scicos_blocks/src/c/mat_reshape.c
scilab/modules/scicos_blocks/src/c/mat_sing.c
scilab/modules/scicos_blocks/src/c/mat_sqrt.c
scilab/modules/scicos_blocks/src/c/mat_sum.c
scilab/modules/scicos_blocks/src/c/mat_sumc.c
scilab/modules/scicos_blocks/src/c/mat_suml.c
scilab/modules/scicos_blocks/src/c/mat_svd.c
scilab/modules/scicos_blocks/src/c/mat_vps.c
scilab/modules/scicos_blocks/src/c/mat_vpv.c
scilab/modules/scicos_blocks/src/c/matbyscal.c
scilab/modules/scicos_blocks/src/c/matbyscal_e.c
scilab/modules/scicos_blocks/src/c/matbyscal_s.c
scilab/modules/scicos_blocks/src/c/mathermit_m.c
scilab/modules/scicos_blocks/src/c/matmul2_e.c
scilab/modules/scicos_blocks/src/c/matmul2_m.c
scilab/modules/scicos_blocks/src/c/matmul2_s.c
scilab/modules/scicos_blocks/src/c/matmul_i16e.c
scilab/modules/scicos_blocks/src/c/matmul_i16n.c
scilab/modules/scicos_blocks/src/c/matmul_i16s.c
scilab/modules/scicos_blocks/src/c/matmul_i32e.c
scilab/modules/scicos_blocks/src/c/matmul_i32n.c
scilab/modules/scicos_blocks/src/c/matmul_i32s.c
scilab/modules/scicos_blocks/src/c/matmul_i8e.c
scilab/modules/scicos_blocks/src/c/matmul_i8n.c
scilab/modules/scicos_blocks/src/c/matmul_i8s.c
scilab/modules/scicos_blocks/src/c/matmul_m.c
scilab/modules/scicos_blocks/src/c/matmul_ui16e.c
scilab/modules/scicos_blocks/src/c/matmul_ui16n.c
scilab/modules/scicos_blocks/src/c/matmul_ui16s.c
scilab/modules/scicos_blocks/src/c/matmul_ui32e.c
scilab/modules/scicos_blocks/src/c/matmul_ui32n.c
scilab/modules/scicos_blocks/src/c/matmul_ui32s.c
scilab/modules/scicos_blocks/src/c/matmul_ui8e.c
scilab/modules/scicos_blocks/src/c/matmul_ui8n.c
scilab/modules/scicos_blocks/src/c/matmul_ui8s.c
scilab/modules/scicos_blocks/src/c/mattran_m.c
scilab/modules/scicos_blocks/src/c/matz_abs.c
scilab/modules/scicos_blocks/src/c/matz_absc.c
scilab/modules/scicos_blocks/src/c/matz_bksl.c
scilab/modules/scicos_blocks/src/c/matz_cath.c
scilab/modules/scicos_blocks/src/c/matz_cath.h [new file with mode: 0644]
scilab/modules/scicos_blocks/src/c/matz_catv.c
scilab/modules/scicos_blocks/src/c/matz_conj.c
scilab/modules/scicos_blocks/src/c/matz_det.c
scilab/modules/scicos_blocks/src/c/matz_diag.c
scilab/modules/scicos_blocks/src/c/matz_div.c
scilab/modules/scicos_blocks/src/c/matz_expm.c
scilab/modules/scicos_blocks/src/c/matz_inv.c
scilab/modules/scicos_blocks/src/c/matz_lu.c
scilab/modules/scicos_blocks/src/c/matz_pinv.c
scilab/modules/scicos_blocks/src/c/matz_reim.c
scilab/modules/scicos_blocks/src/c/matz_reimc.c
scilab/modules/scicos_blocks/src/c/matz_reshape.c
scilab/modules/scicos_blocks/src/c/matz_sing.c
scilab/modules/scicos_blocks/src/c/matz_sqrt.c
scilab/modules/scicos_blocks/src/c/matz_sum.c
scilab/modules/scicos_blocks/src/c/matz_sumc.c
scilab/modules/scicos_blocks/src/c/matz_suml.c
scilab/modules/scicos_blocks/src/c/matz_svd.c
scilab/modules/scicos_blocks/src/c/matz_vps.c
scilab/modules/scicos_blocks/src/c/matz_vpv.c
scilab/modules/scicos_blocks/src/c/matzmul2_m.c
scilab/modules/scicos_blocks/src/c/matzmul_m.c
scilab/modules/scicos_blocks/src/c/matztran_m.c
scilab/modules/scicos_blocks/src/c/minmax.c
scilab/modules/scicos_blocks/src/c/modulo_count.c
scilab/modules/scicos_blocks/src/c/mswitch.c
scilab/modules/scicos_blocks/src/c/multiplex.c
scilab/modules/scicos_blocks/src/c/plusblk.c
scilab/modules/scicos_blocks/src/c/prod.c
scilab/modules/scicos_blocks/src/c/product.c
scilab/modules/scicos_blocks/src/c/ramp.c
scilab/modules/scicos_blocks/src/c/ratelimiter.c
scilab/modules/scicos_blocks/src/c/readau.c
scilab/modules/scicos_blocks/src/c/readc.c
scilab/modules/scicos_blocks/src/c/relational_op.c
scilab/modules/scicos_blocks/src/c/relational_op_i16.c
scilab/modules/scicos_blocks/src/c/relational_op_i32.c
scilab/modules/scicos_blocks/src/c/relational_op_i8.c
scilab/modules/scicos_blocks/src/c/relational_op_ui16.c
scilab/modules/scicos_blocks/src/c/relational_op_ui32.c
scilab/modules/scicos_blocks/src/c/relational_op_ui8.c
scilab/modules/scicos_blocks/src/c/relationalop.c
scilab/modules/scicos_blocks/src/c/relay.c
scilab/modules/scicos_blocks/src/c/ricc_m.c
scilab/modules/scicos_blocks/src/c/rndblk_m.c
scilab/modules/scicos_blocks/src/c/rndblkz_m.c
scilab/modules/scicos_blocks/src/c/root_coef.c
scilab/modules/scicos_blocks/src/c/rootz_coef.c
scilab/modules/scicos_blocks/src/c/samphold4.c
scilab/modules/scicos_blocks/src/c/samphold4_m.c
scilab/modules/scicos_blocks/src/c/satur.c
scilab/modules/scicos_blocks/src/c/scalar2vector.c
scilab/modules/scicos_blocks/src/c/scicos_blocks.vcproj
scilab/modules/scicos_blocks/src/c/scicosexit.c
scilab/modules/scicos_blocks/src/c/scoGetProperty.c
scilab/modules/scicos_blocks/src/c/scoMemoryScope.c
scilab/modules/scicos_blocks/src/c/scoMisc.c
scilab/modules/scicos_blocks/src/c/scoSetProperty.c
scilab/modules/scicos_blocks/src/c/scoWindowScope.c
scilab/modules/scicos_blocks/src/c/selector.c
scilab/modules/scicos_blocks/src/c/selector_m.c
scilab/modules/scicos_blocks/src/c/shift_16_LA.c
scilab/modules/scicos_blocks/src/c/shift_16_LC.c
scilab/modules/scicos_blocks/src/c/shift_16_RA.c
scilab/modules/scicos_blocks/src/c/shift_16_RC.c
scilab/modules/scicos_blocks/src/c/shift_32_LA.c
scilab/modules/scicos_blocks/src/c/shift_32_LC.c
scilab/modules/scicos_blocks/src/c/shift_32_RA.c
scilab/modules/scicos_blocks/src/c/shift_32_RC.c
scilab/modules/scicos_blocks/src/c/shift_8_LA.c
scilab/modules/scicos_blocks/src/c/shift_8_LC.c
scilab/modules/scicos_blocks/src/c/shift_8_RA.c
scilab/modules/scicos_blocks/src/c/shift_8_RC.c
scilab/modules/scicos_blocks/src/c/shift_u16_RA.c
scilab/modules/scicos_blocks/src/c/shift_u32_RA.c
scilab/modules/scicos_blocks/src/c/shift_u8_RA.c
scilab/modules/scicos_blocks/src/c/signum.c
scilab/modules/scicos_blocks/src/c/sin_blk.c
scilab/modules/scicos_blocks/src/c/sinh_blk.c
scilab/modules/scicos_blocks/src/c/step_func.c
scilab/modules/scicos_blocks/src/c/submat.c
scilab/modules/scicos_blocks/src/c/submatz.c
scilab/modules/scicos_blocks/src/c/sum.c
scilab/modules/scicos_blocks/src/c/summation.c
scilab/modules/scicos_blocks/src/c/summation_i16e.c
scilab/modules/scicos_blocks/src/c/summation_i16n.c
scilab/modules/scicos_blocks/src/c/summation_i16s.c
scilab/modules/scicos_blocks/src/c/summation_i32e.c
scilab/modules/scicos_blocks/src/c/summation_i32n.c
scilab/modules/scicos_blocks/src/c/summation_i32s.c
scilab/modules/scicos_blocks/src/c/summation_i8e.c
scilab/modules/scicos_blocks/src/c/summation_i8n.c
scilab/modules/scicos_blocks/src/c/summation_i8s.c
scilab/modules/scicos_blocks/src/c/summation_ui16e.c
scilab/modules/scicos_blocks/src/c/summation_ui16n.c
scilab/modules/scicos_blocks/src/c/summation_ui16s.c
scilab/modules/scicos_blocks/src/c/summation_ui32e.c
scilab/modules/scicos_blocks/src/c/summation_ui32n.c
scilab/modules/scicos_blocks/src/c/summation_ui32s.c
scilab/modules/scicos_blocks/src/c/summation_ui8e.c
scilab/modules/scicos_blocks/src/c/summation_ui8n.c
scilab/modules/scicos_blocks/src/c/summation_ui8s.c
scilab/modules/scicos_blocks/src/c/summation_z.c
scilab/modules/scicos_blocks/src/c/switch2.c
scilab/modules/scicos_blocks/src/c/switch2_m.c
scilab/modules/scicos_blocks/src/c/switchn.c
scilab/modules/scicos_blocks/src/c/tablex2d_c.c
scilab/modules/scicos_blocks/src/c/tan_blk.c
scilab/modules/scicos_blocks/src/c/tanh_blk.c
scilab/modules/scicos_blocks/src/c/tcslti4.c
scilab/modules/scicos_blocks/src/c/tcsltj4.c
scilab/modules/scicos_blocks/src/c/time_delay.c
scilab/modules/scicos_blocks/src/c/tows_c.c
scilab/modules/scicos_blocks/src/c/variable_delay.c
scilab/modules/scicos_blocks/src/c/whileiterator.c
scilab/modules/scicos_blocks/src/c/writeau.c
scilab/modules/scicos_blocks/src/c/writec.c
scilab/modules/scicos_blocks/src/c/zcross2.c

index 2677ce8..227226c 100644 (file)
@@ -140,7 +140,8 @@ includes/scicos.h \
 includes/gw_scicos.h \
 includes/scicos-def.h \
 includes/scicos_free.h \
-includes/scicos_malloc.h
+includes/scicos_malloc.h \
+includes/scicos_math.h
 
 #### scicos : cosf files ####
 libsciscicos_la_cosfdir=$(mydatadir)
diff --git a/scilab/modules/scicos/includes/scicos_math.h b/scilab/modules/scicos/includes/scicos_math.h
new file mode 100644 (file)
index 0000000..4c9ce67
--- /dev/null
@@ -0,0 +1,41 @@
+/*  Scicos
+*
+*  Copyright (C) DIGITEO - 2009 - Allan CORNET
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
+
+#ifndef __SCICOS_MATH_H__
+#define __SCICOS_MATH_H__
+
+/*--------------------------------------------------------------------------*/ 
+#ifdef abs
+       #undef abs
+#endif
+#define abs(x) ((x) >= 0 ? (x) : -(x))
+/*--------------------------------------------------------------------------*/ 
+#ifdef max
+       #undef max
+#endif
+#define max(a,b) ((a) >= (b) ? (a) : (b))
+
+#ifdef min
+       #undef min
+#endif
+#define min(a,b) ((a) <= (b) ? (a) : (b))
+/*--------------------------------------------------------------------------*/ 
+#endif /* __SCICOS_MATH_H__ */
index 0dc91c9..f156244 100644 (file)
@@ -66,8 +66,8 @@
 #include "kinsol.h"
 #include "kinsol_dense.h"
 #include "cvstr.h"
-
 #include "ezxml.h"
+#include "scicos_math.h"
 
 #if defined(linux) && defined(__i386__)
 #include "setPrecisionFPU.h"
@@ -85,15 +85,6 @@ typedef struct {
 } *UserData;
 
 
-#ifdef abs
-#undef abs
-#endif
-#define abs(x) ((x) >= 0 ? (x) : -(x))
-#ifndef WIN32
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
 #define freeall \
        if (*neq>0) CVodeFree(&cvode_mem);\
        if (*neq>0) N_VDestroy_Serial(y);\
index cadcf02..cc8cdf3 100644 (file)
                                RelativePath="..\..\includes\scicos_malloc.h"
                                >
                        </File>
+                       <File
+                               RelativePath="..\..\includes\scicos_math.h"
+                               >
+                       </File>
                </Filter>
                <Filter
                        Name="localization"
index f24a7d9..7aed0fe 100644 (file)
@@ -415,6 +415,7 @@ libsciscicos_blocks_la_CFLAGS= -I$(srcdir)/includes/ \
                        -I$(top_srcdir)/modules/renderer/includes/ \
                        -I$(top_srcdir)/modules/output_stream/includes \
                        -I$(top_srcdir)/modules/scicos/includes \
+                       -I$(top_srcdir)/modules/fileio/includes \
             -I$(top_srcdir)/modules/elementary_functions/includes
 
 
index e2340d1..559e39c 100644 (file)
@@ -1,3 +1,24 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
+
 #ifndef __SCICOS_BLOCK_H__
 #define __SCICOS_BLOCK_H__
 
@@ -95,8 +116,5 @@ double log_(double );
        #define min(a,b) ((a) <= (b) ? (a) : (b))
 #endif
 
-extern int s_copy();
-extern int s_cmp();
-
 
 #endif /* __SCICOS_BLOCK_H__ */
index 388db08..2adb18b 100755 (executable)
@@ -1,3 +1,24 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
+
 #ifndef __SCICOS_BLOCK4_H__
 #define __SCICOS_BLOCK4_H__
 
@@ -13,6 +34,8 @@
        #define NULL 0
 #endif
 
+#include "scicos_math.h"
+
 typedef void (*voidg)();
 
 /* scicos_block structure definition 
@@ -136,14 +159,6 @@ double log_(double );
  void Coserror();
 #endif
 
-/* define min max for win32 */
-#ifndef WIN32
-       #define max(a,b) ((a) >= (b) ? (a) : (b))
-       #define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-extern int s_copy();
-extern int s_cmp();
 
 /* Define scicos simulator data type number (_N) */
 #define SCSREAL_N 10
index 7bbb261..a1d0302 100755 (executable)
@@ -40,17 +40,6 @@ void scoScopeError(ScopeMemory * pScopeMemory, int code_error);
 
 /**
  */
-extern int C2F(getlabel)();
-
-/**
- */
-extern int C2F(deletewin)();
-
-/**
- */
-
-/**
- */
 int permutobj(sciPointObj *pobj_1, sciPointObj *pparent_1,
               sciPointObj *pobj_2, sciPointObj *pparent_2);
 #endif
index 79c97af..0bc9235 100644 (file)
@@ -1,7 +1,24 @@
+/*  Scicos
+*
+*  Copyright (C) DIGITEO - 2009 - Allan CORNET
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
 /*--------------------------------------------------------------------------*/
-/* INRIA 2008 */
-/* Allan CORNET */
-/*--------------------------------------------------------------------------*/ 
 #include <windows.h> 
 /*--------------------------------------------------------------------------*/ 
 #pragma comment(lib,"../../../../bin/libintl.lib")
index 3c81f80..ef419b8 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-
 #include "core_math.h"
-
 #include "scicos.h"
 #include "elementary_functions.h" /* C2F(dmmul) */
+/*--------------------------------------------------------------------------*/ 
 /*------------------------------------------------
  *     Scicos block simulator 
  *     A set of elementary blocks 
  *------------------------------------------------*/
-#ifdef Abs
-       #undef Abs
-#endif
-#define Abs(x) ( (x) > 0) ? (x) : -(x)
 
 /*------------------------------------------------
  *     Scicos block simulator 
  *     returns Absolute value of the input 
  *------------------------------------------------*/
-
-
 void absblk( flag, nevprt, t, xd, x, nx, z, nz, tvec, 
             ntvec, rpar, nrpar, ipar, nipar, u, nu, y, ny)
              int *flag, *nevprt,*nx,*nz,*nrpar, *ipar, *nipar,*ntvec,*nu,*ny;
@@ -48,4 +42,5 @@ void absblk( flag, nevprt, t, xd, x, nx, z, nz, tvec,
   int i;
   for (i = 0 ; i <  *nu ; ++i ) y[i] = Abs(u[i]);
 } 
+/*--------------------------------------------------------------------------*/ 
 
index 2a5b4df..665e160 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
-
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void  absolute_value(scicos_block *block,int flag)
 {
   int i,j;
@@ -66,3 +65,4 @@ void  absolute_value(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 0bdc574..6074251 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void acos_blk(scicos_block *block,int flag)
 {
   int j;
@@ -31,3 +31,4 @@ void acos_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 7f90191..e328bfb 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 #if _MSC_VER
 extern double acosh(double x);
 #endif
-
+/*--------------------------------------------------------------------------*/ 
 void acosh_blk(scicos_block *block,int flag)
 {
   int j;
@@ -35,3 +35,4 @@ void acosh_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 69cac30..fb28773 100644 (file)
@@ -10,7 +10,7 @@
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
-
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include "GetProperty.h"
 #include "SetProperty.h"
@@ -21,7 +21,7 @@
 #include "StringMatrix.h"
 #include "affich.h"
 #include "WindowList.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** Index of the text object within the block (ie compound) */
 #define TEXT_INDEX_IN_BLOCK 1
 
@@ -72,11 +72,7 @@ void C2F(affichin)( int * fontId,
   sciSetAutoSize(pText, TRUE);
   sciSetText(pText, &defaultText, 1, 1);
 
-
   sciDrawObj(pText);
-
-
-
 }
 /*---------------------------------------------------------------------------------*/
 void C2F(affichup)( double * textIndex,
@@ -91,9 +87,6 @@ void C2F(affichup)( double * textIndex,
   /* Second step update text data */
   sciSetText(pText, &value, 1, 1);
   sciDrawObj(pText);
-
-
-
 }
 /*---------"affich2" Initialization ------------------------------------------------*/
 void C2F(affin2)( int * fontId, 
@@ -126,8 +119,6 @@ void C2F(affin2)( int * fontId,
   sciDrawObj(pText);
 
   deleteMatrix(mat);
-
-
 }
 /*---------------------------------------------------------------------------------*/
 void C2F(settxtel)( int * numRow, 
@@ -146,7 +137,6 @@ void C2F(settxtel)( int * numRow,
 
   /* Set matrix element */
   copyStrMatElement(mat, (*numRow) - 1, (*numCol) - 1, value);
-
 }
 /*---------------------------------------------------------------------------------*/
 void C2F(affup2)( double * winNum, 
@@ -160,7 +150,5 @@ void C2F(affup2)( double * winNum,
 
   /* Second step draw the object */
   sciDrawObj(pText);
-
-
 }
 /*---------------------------------------------------------------------------------*/
index f6b2a56..d0fcc4c 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-
 #include "core_math.h"
-
 #include "scicos.h"
-
+/*--------------------------------------------------------------------------*/ 
 /*------------------------------------------------
  *     Scicos block simulator 
  *     A set of elementary blocks 
@@ -44,5 +43,6 @@ void andlog(flag, nevprt, t, xd, x, nx, z, nz, tvec,
 {
   if ( *flag == 1)  y[0] = ( *nevprt != 3 ) ? -1.00 :  1.00; 
 }
+/*--------------------------------------------------------------------------*/ 
 
 
index 3cb5f0c..9a9f405 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void asin_blk(scicos_block *block,int flag)
 {
   int j;
@@ -31,3 +31,4 @@ void asin_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 2fed171..b3f9c8d 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 #if _MSC_VER
 extern double asinh(double x);
 #endif
-
+/*--------------------------------------------------------------------------*/ 
 void asinh_blk(scicos_block *block,int flag)
 {
   int j;
@@ -35,3 +35,4 @@ void asinh_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index e97169c..876b3f9 100644 (file)
@@ -1,7 +1,28 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <memory.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void assignment(scicos_block *block,int flag)
 {
   int my,ny,so;
@@ -164,3 +185,4 @@ void assignment(scicos_block *block,int flag)
     if (*(block->work)!=0) scicos_free(*(block->work));
   } 
 }
+/*--------------------------------------------------------------------------*/ 
index 45d8da7..ea26758 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void atan_blk(scicos_block *block,int flag)
 {
   int j;
@@ -31,3 +31,4 @@ void atan_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 44d1316..6a81fa6 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 #if _MSC_VER
 extern double atanh(double x);
 #endif
-
+/*--------------------------------------------------------------------------*/ 
 void atanh_blk(scicos_block *block,int flag)
 {
   int j;
@@ -35,3 +35,4 @@ void atanh_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 8e29d00..338bde0 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 /* A swithcing mechansim for building hybrid automata */
 /* Masoud Najafi, 2007, INRIA */
 
@@ -137,4 +138,5 @@ void automat(scicos_block *block,int flag)
       x[i]=ui[i+NX]; /*reinitialize the states*/    
   }
 }
+/*--------------------------------------------------------------------------*/ 
 
index d19429f..b6e384d 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
+#include "MALLOC.h"
 #include "scicos_block.h"
-
-
-#ifndef NULL
-#define NULL    0
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 void backlash(scicos_block *block,int flag)
 { 
   double* rw,t;
@@ -70,3 +67,4 @@ void backlash(scicos_block *block,int flag)
     }
   } 
 }
+/*--------------------------------------------------------------------------*/ 
index c7e1eff..184dc4e 100644 (file)
@@ -18,9 +18,9 @@
 *
 * See the file ./license.txt
 */
-
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 void bidon(scicos_block *block,int flag)
 /*------------------------------------------------
  *     Scicos block simulator 
@@ -29,3 +29,4 @@ void bidon(scicos_block *block,int flag)
 {
   //** do nothing :) 
 }
+/*--------------------------------------------------------------------------*/ 
index 69ed342..1347de5 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void bit_clear_16(scicos_block *block,int flag)
 {
   int m,n,i;
@@ -34,3 +34,4 @@ void bit_clear_16(scicos_block *block,int flag)
   y=Getint16OutPortPtrs(block,1);
   for (i=0;i<m*n;i++) y[i]=((u[i])&(*opar));
 }
+/*--------------------------------------------------------------------------*/ 
index af96f00..c189884 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void bit_clear_32(scicos_block *block,int flag)
 {
   int n,m,i;
@@ -34,3 +34,4 @@ void bit_clear_32(scicos_block *block,int flag)
   n=GetInPortCols(block,1);
   for (i=0;i<m*n;i++) *(y+i)=((*(u+i))&(*opar));
 }
+/*--------------------------------------------------------------------------*/ 
index 722e8c3..0ef8aa6 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void bit_clear_8(scicos_block *block,int flag)
 {
   int n,m,i;
@@ -34,3 +34,4 @@ void bit_clear_8(scicos_block *block,int flag)
   m=GetInPortRows(block,1);
   for (i=0;i<m*n;i++) *(y+i)=((*(u+i))&(*opar));
 }
+/*--------------------------------------------------------------------------*/ 
index fc6de68..cafb52b 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void bit_set_16(scicos_block *block,int flag)
 {
   int n,m,i;
@@ -34,3 +34,4 @@ void bit_set_16(scicos_block *block,int flag)
   m=GetInPortRows(block,1);
   for (i=0;i<m*n;i++) *(y+i)=((*(u+i))|(*opar));
 }
+/*--------------------------------------------------------------------------*/ 
index e7b221e..a050da2 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void bit_set_32(scicos_block *block,int flag)
 {
   int n,m,i;
@@ -34,3 +34,4 @@ void bit_set_32(scicos_block *block,int flag)
   m=GetInPortRows(block,1);
   for (i=0;i<m*n;i++) *(y+i)=((*(u+i))|(*opar));
 }
+/*--------------------------------------------------------------------------*/ 
index cf93d44..b8bb8e7 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void bit_set_8(scicos_block *block,int flag)
 {
   int n,m,i;
@@ -34,3 +34,4 @@ void bit_set_8(scicos_block *block,int flag)
   m=GetInPortRows(block,1);
   for(i=0;i<m*n;i++) *(y+i)=((*(u+i))|(*opar));
 }
+/*--------------------------------------------------------------------------*/ 
index 03ecd9a..4ec6b6b 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 void bounce_ball(scicos_block *block,int flag)
 {
 
@@ -156,3 +157,4 @@ void bounce_ball(scicos_block *block,int flag)
     }
   }
 } 
+/*--------------------------------------------------------------------------*/ 
index 9890202..ea35e50 100644 (file)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file bouncexy.c
    \author Benoit Bayol
@@ -35,7 +36,7 @@
 #include "scicos_block4.h"
 #include "ObjectStructure.h"
 #include "DrawingBridge.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn bouncexy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -122,7 +123,7 @@ void bouncexy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstd
   scicos_free(size_balls);
 
 }
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void bouncexy(scicos_block * block,int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -197,3 +198,4 @@ void bouncexy(scicos_block * block,int flag)
       }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 698ec6c..2b634f6 100755 (executable)
@@ -18,6 +18,7 @@
  *
  * See the file ./license.txt
  */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file canimxy.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CANIMXY is a scope in 2D which draw its input as a XY scope, there is animation.
    \see CANIMXY.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
 #include "scoWindowScope.h"
@@ -34,7 +36,7 @@
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
 #include "DrawingBridge.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn canimxy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -191,7 +193,7 @@ void canimxy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdr
       scoAddTitlesScope(*pScopeMemory,label,"x","y",NULL);
     }
 }
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void canimxy(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -275,3 +277,4 @@ void canimxy(scicos_block * block, int flag)
  
     }
 }
+/*--------------------------------------------------------------------------*/ 
index ae2ff3e..fa5092d 100644 (file)
@@ -18,6 +18,7 @@
  *
  * See the file ./license.txt
  */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file canimxy3d.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CANIMXY3D is a scope in 3D which draw its input as a XY scope, there is animation.
    \see CANIMXY3D.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
 #include "scoWindowScope.h"
@@ -34,7 +36,7 @@
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
 #include "DrawingBridge.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn canimxy3d_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -196,6 +198,7 @@ void canimxy3d_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int first
   scicos_free(color);
   scicos_free(line_size);
 }
+/*--------------------------------------------------------------------------*/ 
 /** \fn void canimxy3d(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -281,3 +284,4 @@ void canimxy3d(scicos_block * block, int flag)
  
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 24de444..7ce5c8b 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h> /* sin */
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cdummy(scicos_block *block,int flag)
 /*------------------------------------------------
  *     Scicos block simulator 
@@ -30,3 +31,4 @@ void cdummy(scicos_block *block,int flag)
   if (flag == 0)
     block->xd[0] = sin(get_scicos_time());
 }
+/*--------------------------------------------------------------------------*/ 
index 3ac7c61..2f62d29 100755 (executable)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cevscpe.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CEVSCPE is a scope that indicates when the clocks is activated
    \see CEVENTSCOPE.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
 #include "scoWindowScope.h"
@@ -35,7 +37,7 @@
 #include "scicos_block4.h"
 #include "DrawingBridge.h"
 #include "SetJavaProperty.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn cscopxy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -107,7 +109,7 @@ void cevscpe_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdr
        /* use only single buffering to be sure to draw on the screen */
        sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
 }
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void cevscpe(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -209,3 +211,4 @@ void cevscpe(scicos_block * block, int flag)
                        }
        }
 }
+/*--------------------------------------------------------------------------*/ 
index a150872..c2bcdbe 100755 (executable)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cfscope.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CFSCOPE This scope has no input port because it displays the values on the designated link
    \see CFSCOPE.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
 #include "scoWindowScope.h"
@@ -33,7 +35,9 @@
 #include "scoGetProperty.h"
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
+extern int C2F(getouttb)();
+/*--------------------------------------------------------------------------*/ 
 /** \fn cfscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -110,8 +114,8 @@ void cfscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdr
       scicos_free(colors);
     }
 }
+/*--------------------------------------------------------------------------*/ 
 
-extern int C2F(getouttb)();
 /** \fn void cfscope(scicos_block * block,int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -213,3 +217,4 @@ void cfscope(scicos_block * block,int flag)
       }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 33b32fc..6cf85be 100644 (file)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cmat3d.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CMAT3D is a scope which connect a matrix to a plot3d. Values of the matrix are the values at the nodes.
    \see CMAT3D.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "DrawingBridge.h"
 #include "scoMemoryScope.h"
@@ -34,7 +36,7 @@
 #include "scoGetProperty.h"
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn cmat3d_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -146,7 +148,7 @@ void cmat3d_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdra
   scicos_free(mat);
 
 }
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void cmat3d(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -239,3 +241,4 @@ void cmat3d(scicos_block * block, int flag)
       }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 78628b5..34b4321 100644 (file)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cmatview.c
    \author Benoit Bayol
@@ -26,9 +27,9 @@
    \brief CMATVIEW is a scope that connects a matrix to a grayplot. The values of the matrix are the values at the nodes
   \see CMATVIEW.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include <stdlib.h>
-
 #include "CurrentObjectsManagement.h"
 #include "DrawingBridge.h"
 #include "scoMemoryScope.h"
@@ -37,7 +38,7 @@
 #include "scoGetProperty.h"
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn cmatview_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -97,7 +98,7 @@ void cmatview_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstd
   scicos_free(mat);
 
 }
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void cmatview(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -184,3 +185,4 @@ void cmatview(scicos_block * block, int flag)
       }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 70edc23..65d92a7 100644 (file)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cmscope.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CMSCOPE is a typical scope which links its input to the simulation time
    \see CMSCOPE.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
 #include "scoWindowScope.h"
@@ -34,7 +36,7 @@
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
 #include "SetJavaProperty.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn cmscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -148,7 +150,7 @@ void cmscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdr
        /* use only single buffering to be sure to draw on the screen */
        sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
 }
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void cmscope(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -258,3 +260,4 @@ void cmscope(scicos_block * block, int flag)
       }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index d1ea0bb..bd13bba 100644 (file)
@@ -1,13 +1,31 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 /*     February 2008 */
-/*    Copyright INRIA
- *    Scicos block simulator
- */
-
+/* Scicos block simulator */
+/*--------------------------------------------------------------------------*/ 
 #define NX      block->outsz[0]
-
-
+/*--------------------------------------------------------------------------*/ 
 void constraint_c(scicos_block *block,int flag)
 {
   double *y,*y2,*u;
@@ -48,3 +66,4 @@ void constraint_c(scicos_block *block,int flag)
       default : break;
       }
 }
+/*--------------------------------------------------------------------------*/ 
index 32fd295..810fbdc 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include <memory.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include <memory.h>
+#include "scicos_block4.h"
 #include "sciprint.h"
-
+/*--------------------------------------------------------------------------*/ 
 void convert(scicos_block *block,int flag)
 {
  int m,n,i;
@@ -1153,3 +1152,4 @@ void convert(scicos_block *block,int flag)
           }
        }
  }
+/*--------------------------------------------------------------------------*/ 
index 26e7096..56e97ac 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void cos_blk(scicos_block *block,int flag)
 {
   int j;
@@ -31,3 +31,4 @@ void cos_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index cd37ab7..c73e41a 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-
-#include "core_math.h"
-
 #include "scicos.h"
-
+/*--------------------------------------------------------------------------*/ 
 /*------------------------------------------------
  *     Scicos block simulator 
  *     A set of elementary blocks 
@@ -44,3 +42,5 @@ void cosblk (flag, nevprt, t, xd, x, nx, z, nz, tvec,
   int i ;
   for ( i=0; i < *nu ; i++)     y[i]= cos(u[i]);
 }
+/*--------------------------------------------------------------------------*/ 
+
index 55b06f1..73a2174 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void cosh_blk(scicos_block *block,int flag)
 {
   int j;
@@ -31,3 +31,4 @@ void cosh_blk(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index a5490c1..1bfc3cf 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void counter(scicos_block *block,int flag)
 {
   double *y,*z;
@@ -35,3 +35,4 @@ void counter(scicos_block *block,int flag)
   else if (flag==2) 
     {*z=(1+(int)*z)%(*(ipar+1)-*(ipar+2)+1);}
 } 
+/*--------------------------------------------------------------------------*/ 
index 1cd3f3d..718efde 100644 (file)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cscope.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CSCOPE is a typical scope which links its input to the simulation time but there is only one input instead of CMSCOPE
    \see CSCOPE.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
@@ -35,7 +37,7 @@
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
 #include "SetJavaProperty.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn cscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -112,7 +114,7 @@ void cscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdra
        sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
 
 }
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void cscope(scicos_block * block,int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -211,3 +213,4 @@ void cscope(scicos_block * block,int flag)
       }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 481720e..375c7d2 100755 (executable)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cscopxy.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CSCOPXY is a scope in 2D which draw its input as a XY scope, there is no animation, everything is keep in memory instead of CANIMXY
    \see CSCOPXY.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
 #include "scoWindowScope.h"
@@ -35,7 +37,7 @@
 #include "scicos_block4.h"
 #include "DrawingBridge.h"
 #include "SetJavaProperty.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn cscopxy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -112,8 +114,7 @@ void cscopxy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdr
        /* use only single buffering to be sure to draw on the screen */
        sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
 }
-
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn void cscopxy(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -199,3 +200,4 @@ void cscopxy(scicos_block * block, int flag)
       //free the memory which is allocated at each turn by some variables
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 156fa80..3f471e0 100755 (executable)
@@ -18,6 +18,7 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /**
    \file cscopxy3d.c
    \author Benoit Bayol
@@ -26,6 +27,7 @@
    \brief CSCOPXY3D is a scope in 2D which draw its input as a XYZ scope, there is no animation, everything is keep in memory instead of CANIMXY3D
    \see CSCOPXY3D.sci in macros/scicos_blocks/Sinks/
 */
+/*--------------------------------------------------------------------------*/ 
 #include "CurrentObjectsManagement.h"
 #include "scoMemoryScope.h"
 #include "scoWindowScope.h"
@@ -34,7 +36,7 @@
 #include "scoSetProperty.h"
 #include "scicos_block4.h"
 #include "DrawingBridge.h"
-
+/*--------------------------------------------------------------------------*/ 
 /** \fn cscopxy3d_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -129,6 +131,7 @@ void cscopxy3d_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int first
   scicos_free(color);
   scicos_free(line_size);
 }
+/*--------------------------------------------------------------------------*/ 
 /** \fn void cscopxy3d(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -216,3 +219,4 @@ void cscopxy3d(scicos_block * block, int flag)
       //free the memory which is allocated at each turn by some variables
     }
 }
+/*--------------------------------------------------------------------------*/ 
index babddaf..fbd5f1f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block.h"
 #include "machine.h"
-
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dmmul)();
 extern int C2F(dmmul1)();
-
+/*--------------------------------------------------------------------------*/ 
 void csslti4(scicos_block *block,int flag)
 {
   /*  Copyright INRIA
@@ -65,6 +66,6 @@ void csslti4(scicos_block *block,int flag)
     C2F(dmmul1)(&rpar[lb],&nx,u,insz,xd,&nx,&nx,insz,&un);
   }
 }
-
+/*--------------------------------------------------------------------------*/ 
 
 
index 12ecd3c..549de46 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <memory.h>
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cstblk4(scicos_block *block,int flag)
 { 
   /* Copyright INRIA
@@ -31,3 +32,4 @@ void cstblk4(scicos_block *block,int flag)
   
   memcpy(block->outptr[0],block->rpar,block->nrpar*sizeof(double));    
 }
+/*--------------------------------------------------------------------------*/ 
index 3cf17a5..8cd882d 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <memory.h>
 #include<stdio.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void cstblk4_m(scicos_block *block,int flag)
 { 
   /* Copyright INRIA
@@ -41,3 +41,4 @@ void cstblk4_m(scicos_block *block,int flag)
   so=GetSizeOfOpar(block,1);
   memcpy(y,opar,mo*no*so);
 }
+/*--------------------------------------------------------------------------*/ 
index c997680..e7d1c53 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cumsum_c(scicos_block *block,int flag)
 {
   double *u;
@@ -38,4 +39,4 @@ void cumsum_c(scicos_block *block,int flag)
           {ij=i+j*mu;
            y[ij]=u[ij]+y[ij-mu];}}
 }
-
+/*--------------------------------------------------------------------------*/ 
index a393208..9a3b1b3 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cumsum_m(scicos_block *block,int flag)
 {
   double *u;
@@ -36,3 +37,4 @@ void cumsum_m(scicos_block *block,int flag)
        {y[j]=u[j]+y[j-1];
        }
 }
+/*--------------------------------------------------------------------------*/ 
index 834db33..6a91b36 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cumsum_r(scicos_block *block,int flag)
 {
   double *u;
@@ -39,4 +40,5 @@ void cumsum_r(scicos_block *block,int flag)
           {ij=i+j*mu;
            y[ij]=u[ij]+y[ij-1];}}
 }
+/*--------------------------------------------------------------------------*/ 
 
index c5cf93c..3e56b1e 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cumsumz_c(scicos_block *block,int flag)
 {
   double *ur;
@@ -44,3 +45,4 @@ void cumsumz_c(scicos_block *block,int flag)
            yr[ij]=ur[ij]+yr[ij-mu];
            yi[ij]=ui[ij]+yi[ij-mu];}}
 }
+/*--------------------------------------------------------------------------*/ 
index 7c7ecf2..54cf9d5 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cumsumz_m(scicos_block *block,int flag)
 {
   double *ur;
@@ -39,3 +40,4 @@ void cumsumz_m(scicos_block *block,int flag)
        {yr[j]=ur[j]+yr[j-1];
        yi[j]=ui[j]+yi[j-1];}
 }
+/*--------------------------------------------------------------------------*/ 
index a6400d7..3989d64 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void cumsumz_r(scicos_block *block,int flag)
 {
   double *ur;
@@ -43,3 +44,4 @@ void cumsumz_r(scicos_block *block,int flag)
            yr[ij]=ur[ij]+yr[ij-1];
            yi[ij]=ui[ij]+yi[ij-1];}}
 }
+/*--------------------------------------------------------------------------*/ 
index 8a4a0f6..31cd071 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+#include "MALLOC.h"
+/*--------------------------------------------------------------------------*/ 
 /*    Masoud Najafi, August 2007 */
 /*    Copyright INRIA
  *    Scicos block simulator
  *    Signal builder block
  */
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 #define rpar     block->rpar 
 #define nPoints  block->ipar[0]
 #define Order    block->ipar[1]
 #define Periodic block->ipar[2]
 #define T        rpar[nPoints-1]-rpar[0]
-
+/*--------------------------------------------------------------------------*/ 
 int Myevalhermite(double *t, double *xa, double *xb, double *ya, double *yb, double *da, double *db, double *h, double *dh, double *ddh, double *dddh, int *i);
-
+/*--------------------------------------------------------------------------*/ 
 void curve_c(scicos_block *block,int flag)
 {
   double t,a,b,c,y1,y2,t1,t2;
@@ -182,7 +180,7 @@ void curve_c(scicos_block *block,int flag)
    default : break;
   }
 }
-
+/*--------------------------------------------------------------------------*/ 
 int Myevalhermite(double *t, double *xa, double *xb, double *ya, double *yb, double *da, double *db, double *h, double *dh, double *ddh, double *dddh, int *i)
 {
   double tmxa, p, c2, c3, dx;
@@ -207,4 +205,4 @@ int Myevalhermite(double *t, double *xa, double *xb, double *ya, double *yb, dou
     *h = *ya + *h * tmxa;
     return 0; 
 } /* evalhermite_ */
-
+/*--------------------------------------------------------------------------*/ 
index 830c6ef..1a151c8 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-
 #include "core_math.h"
-
 #include "scicos.h"
-
+/*--------------------------------------------------------------------------*/ 
 /*------------------------------------------------
  *     Scicos block simulator 
  *     A set of elementary blocks 
  *------------------------------------------------*/
 
-#define Min(x,y)       (((x)<(y))?(x):(y))
-#define Max(x,y)       (((x)>(y))?(x):(y))
-
 /*------------------------------------------------
  *     Scicos block simulator 
  *     Dead Band, 
@@ -56,3 +52,4 @@ void dband (flag, nevprt, t, xd, x, nx, z, nz, tvec,
        y[i] = Max(0.00,u[i]-rpar[i]/2.00);
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 70528df..0e69c73 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 void deadband(scicos_block *block,int flag)
 {/* rpar[0]:upper limit,  rpar[1]:lower limit */
   if (flag==1){
@@ -55,4 +56,4 @@ void deadband(scicos_block *block,int flag)
     }
   }
 }
-
+/*--------------------------------------------------------------------------*/ 
index 7c29603..de1a073 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 void delay4(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -45,5 +46,5 @@ void delay4(scicos_block *block,int flag)
     z[nz-1]=u[0];
   }
 }
-
+/*--------------------------------------------------------------------------*/ 
     
index 71e6049..aa2da1c 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void delay4_i16(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -48,3 +49,4 @@ void delay4_i16(scicos_block *block,int flag)
     oz[(mz*nz)-1]=u[0];
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 2aea89c..cd0053e 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void delay4_i32(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -48,3 +49,4 @@ void delay4_i32(scicos_block *block,int flag)
     oz[(mz*nz)-1]=u[0];
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 1eded14..6add2ee 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void delay4_i8(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -48,3 +49,4 @@ void delay4_i8(scicos_block *block,int flag)
     oz[(mz*nz)-1]=u[0];
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 030b211..13ed60e 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void delay4_ui16(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -48,3 +49,4 @@ void delay4_ui16(scicos_block *block,int flag)
     oz[(mz*nz)-1]=u[0];
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 21e6351..b4acaf4 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void delay4_ui32(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -48,3 +49,4 @@ void delay4_ui32(scicos_block *block,int flag)
     oz[(mz*nz)-1]=u[0];
   }
 }
+/*--------------------------------------------------------------------------*/ 
index b40eb74..13ccb20 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void delay4_ui8(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -48,3 +49,4 @@ void delay4_ui8(scicos_block *block,int flag)
     oz[(mz*nz)-1]=u[0];
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 011537a..83c95d2 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
+#include "MALLOC.h"
 #include "scicos_block.h"
-
-
-#ifndef NULL
-#define NULL    0
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 void deriv(scicos_block *block,int flag)
 { 
   double* rw;
@@ -66,4 +63,4 @@ void deriv(scicos_block *block,int flag)
     }
   }
 }
-  
+/*--------------------------------------------------------------------------*/   
index 8d9c732..84eda12 100644 (file)
@@ -1,13 +1,31 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 /*     Februery 2008 */
-/*    Copyright INRIA
- *    Scicos block simulator
- */
-
+/* Scicos block simulator */
+/*--------------------------------------------------------------------------*/ 
 #define NX      block->nx
-
-
+/*--------------------------------------------------------------------------*/ 
 void diffblk_c(scicos_block *block,int flag)
 {
   double *y,*u;
@@ -46,3 +64,4 @@ void diffblk_c(scicos_block *block,int flag)
       default : break;
       }
 }
+/*--------------------------------------------------------------------------*/ 
index 520ebc9..afeda70 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #if _MSC_VER
 #include <stdio.h> /* printf */
 #endif
+#include "scicos_math.h"
+/*--------------------------------------------------------------------------*/ 
 /* Table of constant values */
-
 static double c_b4 = 1.;
 static double c_b5 = 0.;
-
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-int dgemm();
+/*--------------------------------------------------------------------------*/ 
+int dgemm(char *transa, char *transb, int *m, int *n, int *k, double *alpha, 
+                 double *a, int *lda, double *b, int *ldb,double *beta, double *c, 
+                 int *ldc);
+long int lsame(char *, char *);
+int xerbla(char *, int *);
+/*--------------------------------------------------------------------------*/ 
 int dmmul(double *a, int *na, double *b, int *nb, double *c__, 
          int *nc, int *l, int *m, int *n)
 {
@@ -69,10 +75,7 @@ int dmmul(double *a, int *na, double *b, int *nb, double *c__,
            c_b5, &c__[c_offset], nc);
        return 0;
 } /* dmmul */
-
-extern long int lsame(char *, char *);
-extern int xerbla(char *, int *);
-
+/*--------------------------------------------------------------------------*/ 
 int dgemm(char *transa, char *transb, int *m, int *n, int *k, double *alpha, 
          double *a, int *lda, double *b, int *ldb,double *beta, double *c, 
          int *ldc)
@@ -425,7 +428,7 @@ int dgemm(char *transa, char *transb, int *m, int *n, int *k, double *alpha,
   /*     End of DGEMM . */
   
 } /* dgemm */
-
+/*--------------------------------------------------------------------------*/ 
 long int lsame(char *ca, char *cb)
 {
   /* System generated locals */
@@ -529,7 +532,7 @@ long int lsame(char *ca, char *cb)
   
   return ret_val;
 } /* lsame */
-
+/*--------------------------------------------------------------------------*/ 
 int xerbla(char *srname, int *info)
 {
   
@@ -570,4 +573,4 @@ int xerbla(char *srname, int *info)
   /*     End of XERBLA */
   return 0; 
 } /* xerbla */
-
+/*--------------------------------------------------------------------------*/ 
index c884b46..ce49349 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 /* Table of constant values */
-
 static int c__1 = 1;
-extern double ddot();
-
+/*--------------------------------------------------------------------------*/ 
+double ddot(int *n, double *dx, int *incx, double *dy, int *incy);
+/*--------------------------------------------------------------------------*/ 
 int dmmul1(double *a, int *na, double *b, int *nb, double *c__, 
           int *nc, int *l, int *m, int *n)
 {
@@ -74,7 +75,7 @@ int dmmul1(double *a, int *na, double *b, int *nb, double *c__,
   }
   return 0;
 } /* dmmul1 */
-
+/*--------------------------------------------------------------------------*/ 
 double ddot(int *n, double *dx, int *incx, double *dy, int *incy)
 {
   /* System generated locals */
@@ -159,4 +160,4 @@ double ddot(int *n, double *dx, int *incx, double *dy, int *incy)
   ret_val = dtemp;
   return ret_val;
 } /* ddot */
-
+/*--------------------------------------------------------------------------*/ 
index 2727a44..9f62c1f 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 void dollar4(scicos_block *block,int flag)
 {
   /* c     Copyright INRIA
@@ -35,3 +36,4 @@ void dollar4(scicos_block *block,int flag)
       block->z[i]=block->inptr[0][i];
   }
 }
+/*--------------------------------------------------------------------------*/ 
index abfba7b..17b6b47 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <memory.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         int s;
 } dol_struct ;
-
+/*--------------------------------------------------------------------------*/ 
 void dollar4_m(scicos_block *block,int flag)
 {
   /* c     Copyright INRIA
@@ -62,3 +62,4 @@ void dollar4_m(scicos_block *block,int flag)
       }
 
 }
+/*--------------------------------------------------------------------------*/ 
index 9e6c04b..43f99f3 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "MALLOC.h"
 #include "machine.h"
 #include "scicos_block.h"
-
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dmmul)();
 extern int C2F(dmmul1)();
-
-
+/*--------------------------------------------------------------------------*/ 
 void dsslti4(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -80,5 +80,5 @@ void dsslti4(scicos_block *block,int flag)
     scicos_free(*block->work);
   }
 }
-
+/*--------------------------------------------------------------------------*/ 
 
index 2b62070..16d68b8 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
 #include "sciprint.h"
-
+/*--------------------------------------------------------------------------*/ 
 void edgetrig(scicos_block *block,int flag)
 {
   double z= block->z[0],u=block->inptr[0][0];
@@ -51,3 +52,4 @@ void edgetrig(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 32b1224..c2cffce 100644 (file)
@@ -18,7 +18,7 @@
 *
 * See the file ./license.txt
 */
-
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #if _MSC_VER
 #include <float.h>
 
 #include "scicos_block.h"
 #include "machine.h" /* isinf */
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+#include "scicos_math.h"
+/*--------------------------------------------------------------------------*/ 
 #if _MSC_VER
 /*
 arcsinh z = log (z+sqrt(1+z2))
@@ -47,12 +40,12 @@ double asinh(double x)
 {
   return log(x+sqrt(x*x+1));
 }
-
+/*--------------------------------------------------------------------------*/ 
 double acosh(double x)
 {
   return log(x+sqrt(x*x-1));
 }
-
+/*--------------------------------------------------------------------------*/ 
 /*
 Inverse hyperbolic tangent (Atanh(x)) Log((1 + x) / (1 – x)) / 2 
 */
@@ -61,7 +54,7 @@ double atanh(double x)
        return (double)(log ((1.+x)/(1.-x))/2);
 }
 #endif
-
+/*--------------------------------------------------------------------------*/ 
 void evaluate_expr(scicos_block *block,int flag)
 {
   static double stack [1000];
@@ -530,3 +523,4 @@ void evaluate_expr(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 6655ca6..499384f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
+#include "MALLOC.h"
 #include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 /*    Copyright INRIA
  *    Scicos block simulator
  *    event delay with discrete counter
  */
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
 void evtdly4(scicos_block *block,int flag)
 {
   double t;
@@ -65,3 +63,4 @@ void evtdly4(scicos_block *block,int flag)
    default : break;
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 91e337c..57773f4 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void evtvardly(scicos_block *block,int flag)
 { 
   if (flag==3){
     block->evout[0]=block->inptr[0][0];
   }
 }
+/*--------------------------------------------------------------------------*/ 
 
index b863c14..37f58dc 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void expblk_m(scicos_block *block,int flag)
 {
   double *u;
@@ -38,3 +38,4 @@ void expblk_m(scicos_block *block,int flag)
   for(i=0;i<mu*nu;i++) y[i]=exp(log(*rpar)*u[i]);
   }
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index 85781e5..03282d1 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 void extdiag(scicos_block *block,int flag)
 {
   double *u1;
@@ -44,3 +37,4 @@ void extdiag(scicos_block *block,int flag)
        {ii=i+i*mu;
         *(y+ii)=*(u1+ii);}
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index d732b7d..426259f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 void extdiagz(scicos_block *block,int flag)
 {
   double *ur;
@@ -51,3 +44,4 @@ void extdiagz(scicos_block *block,int flag)
         *(yr+ii)=*(ur+ii);
         *(yi+ii)=*(ui+ii);}
 }
+/*--------------------------------------------------------------------------*/ 
index 8cd2370..1af3ce4 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void extract(scicos_block *block,int flag)
 {
   double *u;
@@ -42,3 +43,4 @@ void extract(scicos_block *block,int flag)
                 *(y+k)=*(u+ij);
                 k++;}}
 }
+/*--------------------------------------------------------------------------*/ 
index 773c4c2..1c37dd0 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_LH(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -35,3 +35,4 @@ void extract_bit_16_LH(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index d9f3305..ff562f1 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_LSB(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -37,3 +37,4 @@ void extract_bit_16_LSB(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index 4e2d7e9..fcab880 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_MSB0(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -37,3 +37,4 @@ void extract_bit_16_MSB0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index c83eaae..8ae4fcf 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_MSB1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -38,3 +38,4 @@ void extract_bit_16_MSB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>(maxim-*ipar);
 }
+/*--------------------------------------------------------------------------*/ 
index ff5e68e..a2ee7fd 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_RB0(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -38,3 +38,4 @@ void extract_bit_16_RB0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index 449c21b..44f5e6d 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_RB1(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -39,3 +39,4 @@ void extract_bit_16_RB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>*ipar;
 }
+/*--------------------------------------------------------------------------*/ 
index 89107d0..9d24854 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_UH0(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -35,3 +35,4 @@ void extract_bit_16_UH0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index fab7832..4d42bdf 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_16_UH1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -36,3 +36,4 @@ void extract_bit_16_UH1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>maxim/2;
 }
+/*--------------------------------------------------------------------------*/ 
index 2232625..7551bec 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_LH(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -35,3 +35,4 @@ void extract_bit_32_LH(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index bc64fa9..612d2b8 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_LSB(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -37,3 +37,4 @@ void extract_bit_32_LSB(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index 127effd..1f38372 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_MSB0(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -37,3 +37,4 @@ void extract_bit_32_MSB0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index 79205d3..c386153 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_MSB1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -38,3 +38,4 @@ void extract_bit_32_MSB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>(maxim-*ipar);
 }
+/*--------------------------------------------------------------------------*/ 
index 03e3b50..79858cc 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_RB0(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -38,3 +38,4 @@ void extract_bit_32_RB0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index c80fb81..8184f86 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_RB1(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -39,3 +39,4 @@ void extract_bit_32_RB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>*ipar;
 }
+/*--------------------------------------------------------------------------*/ 
index f0d27d4..71f8fdd 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_UH0(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -35,3 +35,4 @@ void extract_bit_32_UH0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index 7b55eff..65cbe84 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_32_UH1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -36,3 +36,4 @@ void extract_bit_32_UH1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>maxim/2;
 }
+/*--------------------------------------------------------------------------*/ 
index a661efb..cbb2410 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_LH(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -35,3 +35,4 @@ void extract_bit_8_LH(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index efe3d3e..2140547 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_LSB(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -37,3 +37,4 @@ void extract_bit_8_LSB(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index c51cef9..16457b0 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_MSB0(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -37,3 +37,4 @@ void extract_bit_8_MSB0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index 9683475..f7ab361 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_MSB1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -38,3 +38,4 @@ void extract_bit_8_MSB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>(maxim-*ipar);
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index 50246bb..8332713 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_RB0(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -38,3 +38,4 @@ void extract_bit_8_RB0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index a300f50..8b9447c 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_RB1(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -39,3 +39,4 @@ void extract_bit_8_RB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>*ipar;
 }
+/*--------------------------------------------------------------------------*/ 
index 0a70c34..435a7a0 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_UH0(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -35,3 +35,4 @@ void extract_bit_8_UH0(scicos_block *block,int flag)
         ref=ref+n;}
    *y=(*u)&(ref);
 }
+/*--------------------------------------------------------------------------*/ 
index f7a7cc1..1acadac 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_8_UH1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -36,3 +36,4 @@ void extract_bit_8_UH1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>maxim/2;
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index c9d75b1..b5f553f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u16_MSB1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -38,3 +38,4 @@ void extract_bit_u16_MSB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>(maxim-*ipar);
 }
+/*--------------------------------------------------------------------------*/ 
index a4cbf89..ba558cc 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u16_RB1(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -39,3 +39,4 @@ void extract_bit_u16_RB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>*ipar;
 }
+/*--------------------------------------------------------------------------*/ 
index 7995e06..58594cd 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u16_UH1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -36,3 +36,4 @@ void extract_bit_u16_UH1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>maxim/2;
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index 649e55a..d395652 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u32_MSB1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -38,3 +38,4 @@ void extract_bit_u32_MSB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>(maxim-*ipar);
 }
+/*--------------------------------------------------------------------------*/ 
index 74686e9..63fc93a 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u32_RB1(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -39,3 +39,4 @@ void extract_bit_u32_RB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>*ipar;
 }
+/*--------------------------------------------------------------------------*/ 
index df78904..71c7a09 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u32_UH1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -36,3 +36,4 @@ void extract_bit_u32_UH1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>maxim/2;
 }
+/*--------------------------------------------------------------------------*/ 
index 2e0f92b..44bf952 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u8_MSB1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -38,3 +38,4 @@ void extract_bit_u8_MSB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>(maxim-*ipar);
 }
+/*--------------------------------------------------------------------------*/ 
index 5fee961..b6bb975 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u8_RB1(scicos_block *block,int flag)
 {
    int i,maxim,numb;
@@ -39,3 +39,4 @@ void extract_bit_u8_RB1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>*ipar;
 }
+/*--------------------------------------------------------------------------*/ 
index ac8c0e3..147a7a1 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extract_bit_u8_UH1(scicos_block *block,int flag)
 {
    int i,maxim;
@@ -36,3 +36,4 @@ void extract_bit_u8_UH1(scicos_block *block,int flag)
    *y=(*u)&(ref);
    *y=*y>>maxim/2;
 }
+/*--------------------------------------------------------------------------*/ 
index b4631d2..42f7d21 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void extractor(scicos_block *block,int flag)
 {
   int i,j;
@@ -34,3 +34,4 @@ void extractor(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index efdd403..2a84c60 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void extractz(scicos_block *block,int flag)
 {
   double *ur;
@@ -47,3 +48,4 @@ void extractz(scicos_block *block,int flag)
                 *(yi+k)=*(ui+ij);
                 k++;}}
 }
+/*--------------------------------------------------------------------------*/ 
index cf5804f..62806f4 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void exttril(scicos_block *block,int flag)
 {
   double *u;
@@ -37,3 +38,4 @@ void exttril(scicos_block *block,int flag)
                 *(y+ij)=*(u+ij);
                }}
 }
+/*--------------------------------------------------------------------------*/ 
index 0644544..8d3b3a5 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void exttrilz(scicos_block *block,int flag)
 {
   double *ur;
@@ -43,3 +44,4 @@ void exttrilz(scicos_block *block,int flag)
                 *(yr+ij)=*(ur+ij);
                 *(yi+ij)=*(ui+ij);}}
 }
+/*--------------------------------------------------------------------------*/ 
index cef93ed..aa96b72 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void exttriu(scicos_block *block,int flag)
 {
   double *u;
@@ -37,3 +38,4 @@ void exttriu(scicos_block *block,int flag)
                 *(y+ij)=0;
                }}
 }
+/*--------------------------------------------------------------------------*/ 
index 89b8aaa..1b74f9a 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void exttriuz(scicos_block *block,int flag)
 {
   double *ur;
@@ -43,3 +44,4 @@ void exttriuz(scicos_block *block,int flag)
                 *(yr+ij)=0;
                 *(yi+ij)=0;}}
 }
+/*--------------------------------------------------------------------------*/ 
index 2cf4de0..1d2c348 100644 (file)
@@ -1,6 +1,27 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+* See the file ./license.txt
+*/
+/*--------------------------------------------------------------------------*/ 
 #include <memory.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void foriterator(scicos_block *block,int flag)
 { 
   void *y,*u,*z;
@@ -39,6 +60,6 @@ void foriterator(scicos_block *block,int flag)
     }
   }
 }
-
+/*--------------------------------------------------------------------------*/ 
 
   
index 892ef61..7bf8cd3 100644 (file)
 *
 * See the file ./license.txt
 */
-
+/*--------------------------------------------------------------------------*/ 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
-
-
-#include "scicos_block4.h"
-/*    Masoud Najafi, Alan Layec September 2007 */
-/*    Copyright INRIA
- *    Scicos block simulator
- *    From workspace block
- */
 #include "stack-c.h"
 #include "sciprint.h"
 #include "cvstr.h"
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
+#include "MALLOC.h"
+#include "mopen.h"
+#include "mget.h"
+#include "mclose.h"
+#include "cluni0.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 #define Fnlength  block->ipar[0]
 #define FName     block->ipar[1]
 #define Method     block->ipar[1+Fnlength]
 #define T0        ptr->workt[0]
 #define TNm1      ptr->workt[nPoints-1]
 #define TP        (TNm1-0)
-
-
-extern int C2F(mgetnc)();
-extern void C2F(mopen)();
-extern int C2F(cluni0)(char *name, char *nams, int *ln, long int name_len,long int nams_len);
-extern void C2F(mclose)(int *fd, double *res);
-
-int Mytridiagldltsolve(double *dA, double * lA, double * B, int N);
-int Myevalhermite2(double *t, double *x1, double *x2, double *y1, double *y2, double *d1, double *d2, double *z, double *dz, double *ddz, double *dddz, int *k);
-
-
+/*--------------------------------------------------------------------------*/ 
+static int Mytridiagldltsolve(double *dA, double * lA, double * B, int N);
+static int Myevalhermite2(double *t, double *x1, double *x2, double *y1, double *y2, double *d1, double *d2, double *z, double *dz, double *ddz, double *dddz, int *k);
+/*--------------------------------------------------------------------------*/ 
 /* function to check and extract data coming from an hypermat */
 int Ishm(int *fd,int *Ytype,int *nPoints,int *my,int *ny,int *YsubType);
-
+/*--------------------------------------------------------------------------*/ 
 static char fmtd[3]={'d','l','\000'};
 static char fmti[3]={'i','l','\000'};
 static char fmtl[3]={'l','l','\000'};
@@ -69,11 +56,12 @@ static char fmtc[3]={'c','l','\000'};
 static char fmtul[3]={'u','l','\000'};
 static char fmtus[3]={'u','s','\000'};
 static char fmtuc[3]={'u','c','\000'};
-
+/*--------------------------------------------------------------------------*/ 
 #ifdef hppa
 #undef FILENAME_MAX
 #define FILENAME_MAX 4096
 #endif
+/*--------------------------------------------------------------------------*/ 
 /* work struct for that block */
 typedef struct {
   int nPoints;
@@ -89,8 +77,7 @@ typedef struct {
   void *work;
   double *workt;
 } fromwork_struct ;
-
-
+/*--------------------------------------------------------------------------*/ 
 void fromws_c(scicos_block *block,int flag)
 {
   double t,y1,y2,t1,t2,r;
@@ -1203,7 +1190,7 @@ void fromws_c(scicos_block *block,int flag)
  }
  /*************************************************************************/
 }
-
+/*--------------------------------------------------------------------------*/ 
 int Ishm(int *fd,int *Ytype,int *nPoints,int *my,int *ny,int *YsubType)
 {
  int *ptr_i;
@@ -1268,8 +1255,8 @@ int Ishm(int *fd,int *Ytype,int *nPoints,int *my,int *ny,int *YsubType)
  scicos_free(ptr_i);
  return 1;
 }
-
-int Mytridiagldltsolve(double *dA, double * lA, double * B, int N)
+/*--------------------------------------------------------------------------*/ 
+static int Mytridiagldltsolve(double *dA, double * lA, double * B, int N)
 {
        double Temp;
        int j;
@@ -1288,9 +1275,8 @@ int Mytridiagldltsolve(double *dA, double * lA, double * B, int N)
 
        return 0;
 }
-
-
-int Myevalhermite2(double *t, double *x1, double *x2, double *y1, double *y2, double *d1, double *d2, double *z, double *dz, double *ddz, double *dddz, int *k)
+/*--------------------------------------------------------------------------*/ 
+static int Myevalhermite2(double *t, double *x1, double *x2, double *y1, double *y2, double *d1, double *d2, double *z, double *dz, double *ddz, double *dddz, int *k)
 {
        double Temp, p, p2, p3, D;
        Temp = *t - *x1;
@@ -1307,4 +1293,5 @@ int Myevalhermite2(double *t, double *x1, double *x2, double *y1, double *y2, do
        *z = *y1 + *z * Temp;
        return 0; 
 }  
+/*--------------------------------------------------------------------------*/ 
 
index 775a021..b452d66 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-
 #include "core_math.h"
 #include "elementary_functions.h" /* C2F(dmmul) */
-
 #include "scicos.h"
-
-/*------------------------------------------------
- *     Scicos block simulator 
- *     A set of elementary blocks 
- *------------------------------------------------*/
-
-/*------------------------------------------------
- *     Scicos block simulator 
- *     input to output Gain
- *     rpar=gain matrix
- *------------------------------------------------*/
-
+/*--------------------------------------------------------------------------*/ 
 void gain(flag, nevprt, t, xd, x, nx, z, nz, tvec, 
          ntvec, rpar, nrpar, ipar, nipar, u, nu, y, ny)
           int *flag, *nevprt,*nx,*nz,*nrpar, *ipar, *nipar,*ntvec,*nu,*ny;
@@ -45,3 +33,4 @@ void gain(flag, nevprt, t, xd, x, nx, z, nz, tvec,
   int un = 1;
   C2F(dmmul)(rpar,ny,u,nu,y,ny,ny,nu,&un);
 }
+/*--------------------------------------------------------------------------*/ 
index 7699bff..fdfc36d 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-#include "machine.h"
-
+#include "machine.h" /* C2F */
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dmmul)();
 extern int C2F(dmmul1)();
-
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk(scicos_block *block,int flag)
 {
   int i;
@@ -53,3 +53,4 @@ void gainblk(scicos_block *block,int flag)
     C2F(dmmul)(rpar,&ny,u,&nu,y,&ny,&ny,&nu,&my);
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 7b252a0..d981707 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
-#include "scicos_block4.h"
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i16e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -69,3 +70,4 @@ void gainblk_i16e(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 94e9aa3..df54e5f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i16n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -69,3 +70,4 @@ void gainblk_i16n(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 45d08a4..2a46e3d 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i16s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -66,3 +67,4 @@ void gainblk_i16s(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 4a45f14..3d11a6a 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
 #include "sciprint.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i32e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -71,3 +72,4 @@ void gainblk_i32e(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 725cb3c..693a8cb 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i32n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -70,3 +71,4 @@ void gainblk_i32n(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 99d38db..7ad823f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i32s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -66,3 +67,4 @@ void gainblk_i32s(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 65a2267..10fb88f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
 #include "sciprint.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i8e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -71,3 +72,4 @@ void gainblk_i8e(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 551e996..fb7963b 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i8n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -70,3 +71,4 @@ void gainblk_i8n(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 47dfd73..cbb96b3 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_i8s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -66,3 +67,4 @@ void gainblk_i8s(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index a391760..95b3c92 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
 #include "sciprint.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui16e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -71,3 +72,4 @@ void gainblk_ui16e(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 5130525..0872891 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui16n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -70,3 +71,4 @@ void gainblk_ui16n(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index fe79611..f1bd13d 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui16s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -66,3 +67,4 @@ void gainblk_ui16s(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index e0745cc..79e54c0 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
-#include "scicos_block4.h"
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui32e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -71,3 +72,4 @@ void gainblk_ui32e(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 0498028..30a61f7 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui32n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -70,3 +71,4 @@ void gainblk_ui32n(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 19027bf..4ac990f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui32s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -66,3 +67,4 @@ void gainblk_ui32s(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index d59d20d..91e2f86 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
-#include "scicos_block4.h"
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui8e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -71,3 +72,4 @@ void gainblk_ui8e(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 2f31893..dbb1589 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui8n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -70,3 +71,4 @@ void gainblk_ui8n(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 2be6071..ef38f16 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void gainblk_ui8s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)){
@@ -66,3 +67,4 @@ void gainblk_ui8s(scicos_block *block,int flag)
   }
  }
 }
+/*--------------------------------------------------------------------------*/ 
index 67d026d..45ab110 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void  hystheresis(scicos_block *block,int flag)
 {
   if (flag==1){
@@ -58,3 +58,4 @@ void  hystheresis(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 54e79a2..3e7af7c 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void  integral_func(scicos_block *block,int flag)
-{int i;
+{
+       int i;
   if (flag==0){
     if(block->ng>0){
       for(i=0;i<block->nx;++i) {
@@ -65,3 +66,4 @@ void  integral_func(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 87495e2..01d7c78 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void  integralz_func(scicos_block *block,int flag)
-{int i;
+{
+ int i;
  double *ur,*ui;
  double *yr,*yi;
  ur=GetRealInPortPtrs(block,1);
@@ -78,3 +79,4 @@ void  integralz_func(scicos_block *block,int flag)
     }
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 53fadf5..ef8c7d2 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void invblk4(scicos_block *block,int flag)
 {
   /* Copyright INRIA
@@ -50,3 +50,4 @@ void invblk4(scicos_block *block,int flag)
     }
   } 
 }
+/*--------------------------------------------------------------------------*/ 
index 50a53d0..17d7ba1 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logic(scicos_block *block,int flag)
 {
     char *u,*y;
@@ -58,3 +58,4 @@ void logic(scicos_block *block,int flag)
        }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 23586bf..df3687c 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop(scicos_block *block,int flag)
 {
   int i,j,k,l;
@@ -161,3 +161,4 @@ void logicalop(scicos_block *block,int flag)
       }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 8c20c64..77b5338 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop_i16(scicos_block *block,int flag)
 {
   int i,m,n,nin,k,j,l;
@@ -256,3 +257,4 @@ void logicalop_i16(scicos_block *block,int flag)
             break;
        }
 }
+/*--------------------------------------------------------------------------*/ 
index 3de814e..99649cf 100644 (file)
 *
 * See the file ./license.txt
 */
-
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop_i32(scicos_block *block,int flag)
 {
   int i,m,n,nin,k,j,l;
@@ -258,3 +257,4 @@ void logicalop_i32(scicos_block *block,int flag)
             break;
        }
 }
+/*--------------------------------------------------------------------------*/ 
index cd0f5c2..8163a69 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop_i8(scicos_block *block,int flag)
 {
   int i,m,n,nin,k,j,l;
@@ -257,3 +257,4 @@ void logicalop_i8(scicos_block *block,int flag)
             break;
        }
 }
+/*--------------------------------------------------------------------------*/ 
index 6ee4cf6..dbb05d3 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop_m(scicos_block *block,int flag)
 {
   int i,m,n,nin,k,j,l;
@@ -154,3 +154,4 @@ void logicalop_m(scicos_block *block,int flag)
             break;
        }
 }
+/*--------------------------------------------------------------------------*/ 
index 16f5dce..1ba5af5 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop_ui16(scicos_block *block,int flag)
 {
   int i,m,n,nin,k,j,l;
@@ -257,3 +257,4 @@ void logicalop_ui16(scicos_block *block,int flag)
             break;
        }
 }
+/*--------------------------------------------------------------------------*/ 
index cbfbad4..145ac23 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop_ui32(scicos_block *block,int flag)
 {
   int i,m,n,nin,k,j,l;
@@ -257,3 +257,4 @@ void logicalop_ui32(scicos_block *block,int flag)
             break;
        }
 }
+/*--------------------------------------------------------------------------*/ 
index 015b775..fcfbbd6 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void logicalop_ui8(scicos_block *block,int flag)
 {
   int i,m,n,nin,k,j,l;
@@ -257,3 +257,4 @@ void logicalop_ui8(scicos_block *block,int flag)
             break;
        }
 }
+/*--------------------------------------------------------------------------*/ 
index a62705b..53b7ec3 100644 (file)
 *
 * See the file ./license.txt
 */
-
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
-
-
-//  10/2007 --------
-// Copyright INRIA
-
-
+/*--------------------------------------------------------------------------*/ 
 #define InterpExtrapBlin  1
 #define InterpEndValue    2
 #define InputNearest      3
 #define InputBelow        4
 #define InputAbove        5
 #define InterpExtraplin   6
-
-
+/*--------------------------------------------------------------------------*/ 
 double computeZ2(double *X, double *Y, double *Z, int nx, int ny, int method, double x, double y);
 int indexfinder2(double x, int n, double *LT);
-
+/*--------------------------------------------------------------------------*/ 
 void lookup2d(scicos_block *block,int flag)
 {
   double *y, *u1, *u2;
@@ -69,7 +61,7 @@ void lookup2d(scicos_block *block,int flag)
    default : break;
   }
 }
-
+/*--------------------------------------------------------------------------*/ 
 double computeZ2(double *X, double *Y, double *Z, int nx, int ny, int method, double x, double y)
 {
   int i = 0,j = 0,im = 0,jm = 0;
@@ -151,7 +143,7 @@ double computeZ2(double *X, double *Y, double *Z, int nx, int ny, int method, do
   }
   return z;
 }
-
+/*--------------------------------------------------------------------------*/ 
 int indexfinder2(double x, int n, double *LT)
 {
   int i1, i2, i_mid;
@@ -169,4 +161,4 @@ int indexfinder2(double x, int n, double *LT)
   }    
   return i2;
 }      
-
+/*--------------------------------------------------------------------------*/ 
index 44d99dd..8eccde9 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
+#include "MALLOC.h"
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 /*    Masoud Najafi, January 2008 */
 /*    Copyright INRIA
  *    Scicos block simulator
  *    Lookup table block
  */
-
-#ifndef NULL
-#define NULL    0
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 #define RPAR     block->rpar 
 #define nPoints  block->ipar[0]
 #define Order    block->ipar[1]
 #define Periodic block->ipar[2]
 #define Extrapo  block->ipar[3]
 #define T        RPAR[nPoints-1]-RPAR[0]
+/*--------------------------------------------------------------------------*/ 
 int FindIndex(int, double , int , int , double *, int);
-
 int Myevalhermite(double *t, double *xa, double *xb, double *ya, double *yb, double *da, double *db, double *h, double *dh, double *ddh, double *dddh, int *i);
-
+/*--------------------------------------------------------------------------*/ 
 void lookup_c(scicos_block *block,int flag)
 {
   double a,b,c,y1,y2,t1,t2;
@@ -182,9 +180,7 @@ void lookup_c(scicos_block *block,int flag)
       default : break;
       }
 }
-
-
-
+/*--------------------------------------------------------------------------*/ 
 int FindIndex(int order, double inp, int idown, int iup, double *data, int N)
  {
   int im;
@@ -209,3 +205,4 @@ int FindIndex(int order, double inp, int idown, int iup, double *data, int N)
   
   return idown;
 }
+/*--------------------------------------------------------------------------*/ 
index e98398b..3f49663 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
+#include "MALLOC.h"
 #include "scicos_block4.h"
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 void m_frequ(scicos_block *block,int flag)
 {
   double *mat;
@@ -73,3 +71,4 @@ void m_frequ(scicos_block *block,int flag)
    default : break;
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 337f53c..22ba332 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgetrf)();
 extern double C2F(dlamch)();
 extern double C2F(dlange)();
@@ -29,19 +32,7 @@ extern int C2F(dlacpy)();
 extern int C2F(dgecon)();
 extern int C2F(dgetrs)();
 extern int C2F(dgelsy1)();
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         int *ipiv;
           int *rank;
@@ -52,6 +43,7 @@ typedef struct
          double *LA;
          double *LXB;
 } mat_bksl_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_bksl(scicos_block *block,int flag)
 {
  double *u1;
@@ -193,3 +185,4 @@ else
     C2F(dlacpy)("F",&nu1,&nu2,ptr->LXB,&l,y,&nu1);
     }
 }
+/*--------------------------------------------------------------------------*/ 
index c510b84..8a7a408 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
-
-extern void matz_cath();
-
+#include "scicos_block4.h"
+#include "matz_cath.h"
+/*--------------------------------------------------------------------------*/ 
 void mat_cath(scicos_block *block,int flag)
 {
        int mu,nu,nin,so,pointerposition,ot,i;
@@ -50,3 +47,4 @@ void mat_cath(scicos_block *block,int flag)
                }
        }
 }
+/*--------------------------------------------------------------------------*/ 
index 772d836..b7688c7 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern void matz_catv();
-
+/*--------------------------------------------------------------------------*/ 
 void mat_catv(scicos_block *block,int flag)
 {
        int mu,nu,nin,so,pointerposition,ot,i,j;
@@ -51,4 +49,5 @@ void mat_catv(scicos_block *block,int flag)
                        }
                }
        }
-}
\ No newline at end of file
+}
+/*--------------------------------------------------------------------------*/ 
index f467873..0602263 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
+#include "machine.h"
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgetrf)();
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         int *ipiv;
           double *wrk;
 } mat_det_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_det(scicos_block *block,int flag)
 {
  double *u;
@@ -92,3 +91,4 @@ else
      *y=D;
     }
  }
+/*--------------------------------------------------------------------------*/ 
index c2aef22..3828049 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void mat_diag(scicos_block *block,int flag)
 {
   double *u1;
@@ -36,3 +37,4 @@ void mat_diag(scicos_block *block,int flag)
        {ii=i+i*mu;
         *(y+ii)=*(u1+i);}
 }
+/*--------------------------------------------------------------------------*/ 
index 2f9dd9f..e08930a 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgetrf)();
 extern double C2F(dlamch)();
 extern double C2F(dlange)();
@@ -29,19 +32,7 @@ extern int C2F(dlacpy)();
 extern int C2F(dgecon)();
 extern int C2F(dgetrs)();
 extern int C2F(dgelsy1)();
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         int *ipiv;
           int *rank;
@@ -52,6 +43,7 @@ typedef struct
          double *LBT;
          double *LAT;
 } mat_div_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_div(scicos_block *block,int flag)
 {
  double *u1;
@@ -210,3 +202,4 @@ else
        }
     }
 }
+/*--------------------------------------------------------------------------*/ 
index 48b0999..8c05d66 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
 #include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dexpm1)();
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {        int *iwork;
           double *dwork;
 } mat_exp_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_expm(scicos_block *block,int flag)
 {
  double *u;
@@ -83,3 +81,4 @@ else
        }
    }
 }
+/*--------------------------------------------------------------------------*/ 
index c57ed12..bcdfcd1 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgetrf)();
 extern int C2F(dgetri)();
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         int *ipiv;
           double *dwork;
 } mat_inv_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_inv(scicos_block *block,int flag)
 {
  double *u;
@@ -86,3 +85,4 @@ else
     
    }
 }
+/*--------------------------------------------------------------------------*/ 
index 44a9076..a34ab7a 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgetrf)();
 extern int C2F(dlaswp)();
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         int *ipiv;
           double *dwork;
          double *IL;
          double *IU;
 } mat_lu_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_lu(scicos_block *block,int flag)
 {
  double *u;
@@ -134,3 +125,4 @@ else
        }
    }
 }
+/*--------------------------------------------------------------------------*/ 
index 2c32ec5..8d0876e 100755 (executable)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgesvd)();
 extern int C2F(dlaset)();
 extern int C2F(dlacpy)();
 extern int C2F(dmmul)();
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         double *l0;
          double *LA;
@@ -52,6 +42,7 @@ typedef struct
           double *LVT;
           double *dwork;
 } mat_pinv_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_pinv(scicos_block *block,int flag)
 {
  double *u;
@@ -233,3 +224,4 @@ else
       C2F(dmmul)(ptr->LC,&nu,ptr->LUT,&mu,y,&nu,&nu,&mu,&mu);
    }
 }
+/*--------------------------------------------------------------------------*/ 
index f5a742d..f8c4412 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void mat_reshape(scicos_block *block,int flag)
 {
   double *u1;
@@ -34,3 +35,4 @@ void mat_reshape(scicos_block *block,int flag)
 
   for (i=0;i<xu*vu;i++) *(y+i)=*(u1+i);
 }
+/*--------------------------------------------------------------------------*/ 
index 6ada881..239877e 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgesvd)();
 extern int C2F(dlaset)();
 extern int C2F(dlacpy)();
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {        double *LA;
           double *LU;
           double *LVT;
           double *dwork;
 } mat_sing_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_sing(scicos_block *block,int flag)
 {
  double *u;
@@ -112,3 +103,4 @@ else
          return;}}
    }
 }
+/*--------------------------------------------------------------------------*/ 
index 44fa1ff..32ec0b0 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
-
+/*--------------------------------------------------------------------------*/ 
 void mat_sqrt(scicos_block *block,int flag)
 {
   double *u;
@@ -38,3 +38,4 @@ void mat_sqrt(scicos_block *block,int flag)
   for(i=0;i<mu*nu;i++)  y[i]=pow(u[i],0.5);
 
 }
+/*--------------------------------------------------------------------------*/ 
index f895a49..c7cfacf 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void mat_sum(scicos_block *block,int flag)
 {
   double *u;
@@ -35,3 +36,4 @@ void mat_sum(scicos_block *block,int flag)
   for(i=0;i<nu*mu;i++)
        {y[0]=u[i]+y[0];}
 }
+/*--------------------------------------------------------------------------*/ 
index 60d2706..1755f49 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void mat_sumc(scicos_block *block,int flag)
 {
   double *u;
@@ -39,3 +40,4 @@ void mat_sumc(scicos_block *block,int flag)
            d+=*(u+ij);}
        *(y+j)=d;}
 }
+/*--------------------------------------------------------------------------*/ 
index 52ecc3c..d0f8377 100644 (file)
@@ -18,8 +18,9 @@
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void mat_suml(scicos_block *block,int flag)
 {
   double *u;
@@ -39,3 +40,4 @@ void mat_suml(scicos_block *block,int flag)
            d+=*(u+ij);}
        *(y+j)=d;}
 }
+/*--------------------------------------------------------------------------*/ 
\ No newline at end of file
index ccfc3b0..ab3276f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dgesvd)();
 extern int C2F(dlaset)();
 extern int C2F(dlacpy)();
 extern int C2F(dmmul)();
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
-#ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) ((a) >= (b) ? (a) : (b))
-#endif
-
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         double *l0;
          double *LA;
@@ -46,6 +36,7 @@ typedef struct
           double *LVT;
           double *dwork;
 } mat_sdv_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_svd(scicos_block *block,int flag)
 {
  double *u;
@@ -138,3 +129,4 @@ else
        }
    }
 }
+/*--------------------------------------------------------------------------*/ 
index 2f67ac1..116af0b 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dlacpy)();
 extern int C2F(dgeev)();
 extern int C2F(zlaset)();
 extern int C2F(issymmetric)();
 extern int C2F(dsyev)();
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         double *LA;
           double *LVR;
           double *dwork;
           double *dwork1;
 } mat_vps_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_vps(scicos_block *block,int flag)
 {
  double *u;
@@ -127,3 +126,4 @@ else
        }
    }
 }
+/*--------------------------------------------------------------------------*/ 
index 6a146f1..b2df31b 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
-#if _MSC_VER
-#define NULL    0
-#endif
-
+#include "machine.h" /* C2F */
+#include "MALLOC.h"
+#include "scicos_block4.h"
+#include "../../../linear_algebra/includes/issymmetric.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dlacpy)();
 extern int C2F(dgeev)();
 extern int C2F(dlaset)();
 extern int C2F(issymmetric)();
 extern int C2F(dsyev)();
+/*--------------------------------------------------------------------------*/ 
 typedef struct
 {         double *LA;
          double *L0;
@@ -42,6 +41,7 @@ typedef struct
           double *dwork;
           double *dwork1;
 } mat_vps_struct ;
+/*--------------------------------------------------------------------------*/ 
 void mat_vpv(scicos_block *block,int flag)
 {
  double *u;
@@ -207,3 +207,4 @@ else
        }
    }
 }
+/*--------------------------------------------------------------------------*/ 
index ceb9373..192add2 100644 (file)
 *
 * See the file ./license.txt
 */
-
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 #define matbscal_n(y1,u1,u2,mu,nu)  {for (i=0;i<mu*nu;i++) y1[i]=u1[i]*u2[0];}
-
+/*--------------------------------------------------------------------------*/ 
 void matbyscal(scicos_block *block,int flag)
 {
  if (flag==1){
@@ -109,3 +110,4 @@ void matbyscal(scicos_block *block,int flag)
   }
 
 }
+/*--------------------------------------------------------------------------*/ 
index 7402bab..d9d9737 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include <stdio.h>
-#include "scicos_block4.h"
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matbyscal_e(scicos_block *block,int flag)
 {
  if (flag==1){
@@ -125,3 +126,4 @@ void matbyscal_e(scicos_block *block,int flag)
   }
 
 }
+/*--------------------------------------------------------------------------*/ 
index 874fafd..a9e8752 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void matbyscal_s(scicos_block *block,int flag)
 {
  if (flag==1){
@@ -111,3 +112,4 @@ void matbyscal_s(scicos_block *block,int flag)
   }
 
 }
+/*--------------------------------------------------------------------------*/ 
index 12eef01..9243245 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include "scicos_block4.h"
 #include "machine.h"
-
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(mtran)();
+/*--------------------------------------------------------------------------*/ 
 void mathermit_m(scicos_block *block,int flag)
 {
   double *ur;
@@ -41,4 +43,5 @@ void mathermit_m(scicos_block *block,int flag)
   C2F(mtran)(ui,&nu,yi,&mu,&nu,&mu);
   for(i=0;i<mu*nu;i++) *(yi+i)=-(*(yi+i));
 }
+/*--------------------------------------------------------------------------*/ 
 
index b30bb46..049b622 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include <stdio.h>
 #include "scicos_block4.h"
 #include "sciprint.h"
-
+/*--------------------------------------------------------------------------*/ 
 void matmul2_e(scicos_block *block,int flag)
 {
  if (flag==1){
@@ -124,3 +125,4 @@ void matmul2_e(scicos_block *block,int flag)
    } 
   }
 }
+/*--------------------------------------------------------------------------*/ 
index 91066d1..c85bc3f 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 #define matmul2(y1,u1,u2,mu,nu)  {for (i=0;i<mu*nu;i++) y1[i]=u1[i]*u2[i];}
-
+/*--------------------------------------------------------------------------*/ 
 void matmul2_m(scicos_block *block,int flag)
 {
        if (flag==1){
@@ -108,3 +110,4 @@ void matmul2_m(scicos_block *block,int flag)
        }
 
 }
+/*--------------------------------------------------------------------------*/ 
index 7ab81d3..8935983 100644 (file)
 *
 * See the file ./license.txt
 */
+/*--------------------------------------------------------------------------*/ 
 #include <math.h>
 #include "scicos_block4.h"
-
+/*--------------------------------------------------------------------------*/ 
 void matmul2_s(scicos_block *block,int flag)
 {
  if (flag==1){
@@ -111,3 +112,4 @@ void matmul2_s(scicos_block *block,int flag)
   }
 
 }
+/*--------------------------------------------------------------------------*/ 
index 9a0ac2e..db1ff25 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include <stdio.h>
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i16e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -60,3 +60,4 @@ void matmul_i16e(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 6aa199c..9b09d0f 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i16n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -59,3 +58,4 @@ void matmul_i16n(scicos_block *block,int flag)
             }
      }
 }
+/*--------------------------------------------------------------------------*/ 
index 4d6718c..56a5732 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i16s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -59,3 +58,4 @@ void matmul_i16s(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 9c47173..4b0e694 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include <stdio.h>
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i32e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -60,3 +60,4 @@ void matmul_i32e(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 48d5e6b..61a6755 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i32n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -60,3 +59,4 @@ void matmul_i32n(scicos_block *block,int flag)
             }
      }
 }
+/*--------------------------------------------------------------------------*/ 
index 7fddbf9..89cb151 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i32s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -59,3 +58,4 @@ void matmul_i32s(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index fdf76f3..9d453ad 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include <stdio.h>
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i8e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -60,3 +60,4 @@ void matmul_i8e(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 8ba781c..dda57e7 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i8n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -54,3 +53,4 @@ void matmul_i8n(scicos_block *block,int flag)
             }
      }
 }
+/*--------------------------------------------------------------------------*/ 
index 1321ac8..6c75399 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_i8s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -59,3 +58,4 @@ void matmul_i8s(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 9ce8590..8c98364 100644 (file)
 *
 * See the file ./license.txt
 */
-#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 #include "machine.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 extern int C2F(dmmul)();
 extern int C2F(dmmul1)();
-
+/*--------------------------------------------------------------------------*/ 
 void matmul_m(scicos_block *block,int flag)
 {
   double *u1;
@@ -42,3 +43,4 @@ void matmul_m(scicos_block *block,int flag)
 
   C2F(dmmul)(u1,&nu,u2,&nu2,y,&nu,&nu,&nu2,&mu2);
 }
+/*--------------------------------------------------------------------------*/ 
index 3af5510..1bed4de 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include <stdio.h>
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui16e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -60,3 +60,4 @@ void matmul_ui16e(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 48ffc76..513c9ed 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui16n(scicos_block *block,int flag)
 {
 if ((flag==1)|(flag==6)) {
@@ -56,3 +55,4 @@ if ((flag==1)|(flag==6)) {
             }
      }
 }
+/*--------------------------------------------------------------------------*/ 
index c131702..de828cc 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui16s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -59,3 +58,4 @@ void matmul_ui16s(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 3bc303e..6fb671f 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include <stdio.h>
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui32e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -60,3 +60,4 @@ void matmul_ui32e(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 3873b08..99d0f36 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui32n(scicos_block *block,int flag)
 {
 if ((flag==1)|(flag==6)) {
@@ -56,3 +55,4 @@ if ((flag==1)|(flag==6)) {
             }
      }
 }
+/*--------------------------------------------------------------------------*/ 
index ad0d5ca..41f5702 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui32s(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -59,3 +58,4 @@ void matmul_ui32s(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 5b13552..d32137d 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include <stdio.h>
-# include "scicos_block4.h"
-# include "machine.h"
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include <stdio.h>
 #include "sciprint.h"
-
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui8e(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@ -60,3 +60,4 @@ void matmul_ui8e(scicos_block *block,int flag)
                 }
             }
 }
+/*--------------------------------------------------------------------------*/ 
index 8ba2d36..04335ad 100644 (file)
 *
 * See the file ./license.txt
 */
-# include <math.h>
-# include "scicos_block4.h"
-# include "machine.h"
-
-
+/*--------------------------------------------------------------------------*/ 
+#include <math.h>
+#include "scicos_block4.h"
+/*--------------------------------------------------------------------------*/ 
 void matmul_ui8n(scicos_block *block,int flag)
 {
  if ((flag==1)|(flag==6)) {
@@