/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.6
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

package javagiac;

public class giac {
  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_0(gen.getCPtr(a), a), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_1(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b, gen c) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_2(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b, gen c, gen d) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_3(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b, gen c, gen d, gen e) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_4(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, gen.getCPtr(e), e), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b, gen c, gen d, gen e, gen f) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_5(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, gen.getCPtr(e), e, gen.getCPtr(f), f), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b, gen c, gen d, gen e, gen f, gen g) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_6(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, gen.getCPtr(e), e, gen.getCPtr(f), f, gen.getCPtr(g), g), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b, gen c, gen d, gen e, gen f, gen g, gen h) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_7(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, gen.getCPtr(e), e, gen.getCPtr(f), f, gen.getCPtr(g), g, gen.getCPtr(h), h), true);
  }

  public static SWIGTYPE_p_giac__vecteur makevecteur(gen a, gen b, gen c, gen d, gen e, gen f, gen g, gen h, gen i) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.makevecteur__SWIG_8(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, gen.getCPtr(e), e, gen.getCPtr(f), f, gen.getCPtr(g), g, gen.getCPtr(h), h, gen.getCPtr(i), i), true);
  }

  public static gen _factor(gen g, context contextptr) {
    return new gen(giacJNI._factor(gen.getCPtr(g), g, context.getCPtr(contextptr), contextptr), true);
  }

  public static gen _simplify(gen g, context contextptr) {
    return new gen(giacJNI._simplify(gen.getCPtr(g), g, context.getCPtr(contextptr), contextptr), true);
  }

  public static gen _size(gen g, context contextptr) {
    return new gen(giacJNI._size(gen.getCPtr(g), g, context.getCPtr(contextptr), contextptr), true);
  }

  public static gen add(gen a, gen b) {
    return new gen(giacJNI.add(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen sub(gen a, gen b) {
    return new gen(giacJNI.sub(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen neg(gen a) {
    return new gen(giacJNI.neg(gen.getCPtr(a), a), true);
  }

  public static gen mul(gen a, gen b) {
    return new gen(giacJNI.mul(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen rdiv(gen a, gen b) {
    return new gen(giacJNI.rdiv(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen mod(gen a, gen b) {
    return new gen(giacJNI.mod(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen pow(gen base, gen exponent, context arg2) {
    return new gen(giacJNI.pow__SWIG_0(gen.getCPtr(base), base, gen.getCPtr(exponent), exponent, context.getCPtr(arg2), arg2), true);
  }

  public static gen giac_pow(gen base, gen exponent, context arg2) {
    return new gen(giacJNI.giac_pow(gen.getCPtr(base), base, gen.getCPtr(exponent), exponent, context.getCPtr(arg2), arg2), true);
  }

  public static gen iquo(gen a, gen b) {
    return new gen(giacJNI.iquo(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen irem(gen a, gen b, gen q) {
    return new gen(giacJNI.irem(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(q), q), true);
  }

  public static gen smod(gen a, gen b) {
    return new gen(giacJNI.smod__SWIG_0(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static void smod(SWIGTYPE_p_giac__vecteur v, gen g, SWIGTYPE_p_giac__vecteur w) {
    giacJNI.smod__SWIG_1(SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(g), g, SWIGTYPE_p_giac__vecteur.getCPtr(w));
  }

  public static SWIGTYPE_p_giac__vecteur smod(SWIGTYPE_p_giac__vecteur a, gen b) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.smod__SWIG_2(SWIGTYPE_p_giac__vecteur.getCPtr(a), gen.getCPtr(b), b), true);
  }

  public static gen inv(gen a, context arg1) {
    return new gen(giacJNI.inv(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static boolean operator_equal(gen a, gen b, context arg2) {
    return giacJNI.operator_equal(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2);
  }

  public static gen equal(gen a, gen b, context arg2) {
    return new gen(giacJNI.equal(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static int fastsign(gen a, context arg1) {
    return giacJNI.fastsign(gen.getCPtr(a), a, context.getCPtr(arg1), arg1);
  }

  public static gen sign(gen a, context arg1) {
    return new gen(giacJNI.sign(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static boolean is_greater(gen a, gen b, context arg2) {
    return giacJNI.is_greater(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2);
  }

  public static boolean is_strictly_greater(gen a, gen b, context arg2) {
    return giacJNI.is_strictly_greater(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2);
  }

  public static boolean is_positive(gen a, context arg1) {
    return giacJNI.is_positive(gen.getCPtr(a), a, context.getCPtr(arg1), arg1);
  }

  public static boolean is_strictly_positive(gen a, context arg1) {
    return giacJNI.is_strictly_positive(gen.getCPtr(a), a, context.getCPtr(arg1), arg1);
  }

  public static boolean ck_is_greater(gen a, gen b, context arg2) {
    return giacJNI.ck_is_greater(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2);
  }

  public static boolean ck_is_strictly_greater(gen a, gen b, context arg2) {
    return giacJNI.ck_is_strictly_greater(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2);
  }

  public static boolean ck_is_positive(gen a, context arg1) {
    return giacJNI.ck_is_positive(gen.getCPtr(a), a, context.getCPtr(arg1), arg1);
  }

  public static boolean ck_is_strictly_positive(gen a, context arg1) {
    return giacJNI.ck_is_strictly_positive(gen.getCPtr(a), a, context.getCPtr(arg1), arg1);
  }

  public static gen superieur_strict(gen a, gen b, context arg2) {
    return new gen(giacJNI.superieur_strict(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen superieur_egal(gen a, gen b, context arg2) {
    return new gen(giacJNI.superieur_egal(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen inferieur_strict(gen a, gen b, context arg2) {
    return new gen(giacJNI.inferieur_strict(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen inferieur_egal(gen a, gen b, context arg2) {
    return new gen(giacJNI.inferieur_egal(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static boolean symb_size_less(gen a, gen b) {
    return giacJNI.symb_size_less(gen.getCPtr(a), a, gen.getCPtr(b), b);
  }

  public static gen min(gen a, gen b, context arg2) {
    return new gen(giacJNI.min(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen max(gen a, gen b, context arg2) {
    return new gen(giacJNI.max(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen factorial(long i) {
    return new gen(giacJNI.factorial(i), true);
  }

  public static gen comb(long i, long j) {
    return new gen(giacJNI.comb__SWIG_0(i, j), true);
  }

  public static gen perm(long i, long j) {
    return new gen(giacJNI.perm(i, j), true);
  }

  public static gen pow(gen base, long exponent) {
    return new gen(giacJNI.pow__SWIG_1(gen.getCPtr(base), base, exponent), true);
  }

  public static gen pow(gen base, int exponent) {
    return new gen(giacJNI.pow__SWIG_2(gen.getCPtr(base), base, exponent), true);
  }

  public static gen pow(long base, long exponent) {
    return new gen(giacJNI.pow__SWIG_3(base, exponent), true);
  }

  public static gen gcd(gen A, gen B) {
    return new gen(giacJNI.gcd(gen.getCPtr(A), A, gen.getCPtr(B), B), true);
  }

  public static gen lcm(gen a, gen b) {
    return new gen(giacJNI.lcm(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen simplify(gen n, gen d) {
    return new gen(giacJNI.simplify__SWIG_0(gen.getCPtr(n), n, gen.getCPtr(d), d), true);
  }

  public static void egcd(gen a, gen b, gen u, gen v, gen d) {
    giacJNI.egcd(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(u), u, gen.getCPtr(v), v, gen.getCPtr(d), d);
  }

  public static gen ichinrem(gen a, gen b, gen amod, gen bmod) {
    return new gen(giacJNI.ichinrem(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(amod), amod, gen.getCPtr(bmod), bmod), true);
  }

  public static gen invmod(gen A, gen modulo) {
    return new gen(giacJNI.invmod(gen.getCPtr(A), A, gen.getCPtr(modulo), modulo), true);
  }

  public static gen fracmod(gen a_orig, gen modulo) {
    return new gen(giacJNI.fracmod__SWIG_0(gen.getCPtr(a_orig), a_orig, gen.getCPtr(modulo), modulo), true);
  }

  public static boolean fracmod(gen a_orig, gen modulo, gen res) {
    return giacJNI.fracmod__SWIG_1(gen.getCPtr(a_orig), a_orig, gen.getCPtr(modulo), modulo, gen.getCPtr(res), res);
  }

  public static gen powmod(gen base, gen expo, gen modulo) {
    return new gen(giacJNI.powmod(gen.getCPtr(base), base, gen.getCPtr(expo), expo, gen.getCPtr(modulo), modulo), true);
  }

  public static gen isqrt(gen A) {
    return new gen(giacJNI.isqrt(gen.getCPtr(A), A), true);
  }

  public static gen re(gen a, context arg1) {
    return new gen(giacJNI.re(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen no_context_re(gen a) {
    return new gen(giacJNI.no_context_re(gen.getCPtr(a), a), true);
  }

  public static gen im(gen a, context arg1) {
    return new gen(giacJNI.im(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen no_context_im(gen a) {
    return new gen(giacJNI.no_context_im(gen.getCPtr(a), a), true);
  }

  public static void reim(gen g, gen r, gen i, context arg3) {
    giacJNI.reim(gen.getCPtr(g), g, gen.getCPtr(r), r, gen.getCPtr(i), i, context.getCPtr(arg3), arg3);
  }

  public static gen conj(gen a, context arg1) {
    return new gen(giacJNI.conj(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen no_context_conj(gen a) {
    return new gen(giacJNI.no_context_conj(gen.getCPtr(a), a), true);
  }

  public static gen sq(gen a) {
    return new gen(giacJNI.sq(gen.getCPtr(a), a), true);
  }

  public static gen abs(gen a, context contextptr) {
    return new gen(giacJNI.abs__SWIG_0(gen.getCPtr(a), a, context.getCPtr(contextptr), contextptr), true);
  }

  public static gen abs(gen a) {
    return new gen(giacJNI.abs__SWIG_1(gen.getCPtr(a), a), true);
  }

  public static gen linfnorm(gen a, context contextptr) {
    return new gen(giacJNI.linfnorm__SWIG_0(gen.getCPtr(a), a, context.getCPtr(contextptr), contextptr), true);
  }

  public static gen linfnorm(gen a) {
    return new gen(giacJNI.linfnorm__SWIG_1(gen.getCPtr(a), a), true);
  }

  public static gen arg(gen a, context arg1) {
    return new gen(giacJNI.arg(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen arg_CPLX(gen a, context arg1) {
    return new gen(giacJNI.arg_CPLX(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static int is_perfect_square(gen A) {
    return giacJNI.is_perfect_square(gen.getCPtr(A), A);
  }

  public static int is_probab_prime_p(gen A) {
    return giacJNI.is_probab_prime_p(gen.getCPtr(A), A);
  }

  public static gen nextprime(gen a) {
    return new gen(giacJNI.nextprime(gen.getCPtr(a), a), true);
  }

  public static gen prevprime(gen a) {
    return new gen(giacJNI.prevprime(gen.getCPtr(a), a), true);
  }

  public static int jacobi(gen A, gen B) {
    return giacJNI.jacobi(gen.getCPtr(A), A, gen.getCPtr(B), B);
  }

  public static int legendre(gen A, gen B) {
    return giacJNI.legendre(gen.getCPtr(A), A, gen.getCPtr(B), B);
  }

  public static SWIGTYPE_p_giac__vecteur pascal_next_line(SWIGTYPE_p_giac__vecteur v) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.pascal_next_line(SWIGTYPE_p_giac__vecteur.getCPtr(v)), true);
  }

  public static SWIGTYPE_p_giac__vecteur pascal_nth_line(int n) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.pascal_nth_line(n), true);
  }

  public static gen vector2vecteur(SWIGTYPE_p_giac__vecteur v) {
    return new gen(giacJNI.vector2vecteur(SWIGTYPE_p_giac__vecteur.getCPtr(v)), true);
  }

  public static gen chkmod(gen a, gen b) {
    return new gen(giacJNI.chkmod(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen makemod(gen a, gen b) {
    return new gen(giacJNI.makemod(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static gen makemodquoted(gen a, gen b) {
    return new gen(giacJNI.makemodquoted(gen.getCPtr(a), a, gen.getCPtr(b), b), true);
  }

  public static SWIGTYPE_p_giac__vecteur symbolique2liste(gen x, context arg1) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.symbolique2liste(gen.getCPtr(x), x, context.getCPtr(arg1), arg1), true);
  }

  public static gen liste2symbolique(SWIGTYPE_p_giac__vecteur v) {
    return new gen(giacJNI.liste2symbolique(SWIGTYPE_p_giac__vecteur.getCPtr(v)), true);
  }

  public static boolean is_atomic(gen e) {
    return giacJNI.is_atomic(gen.getCPtr(e), e);
  }

  public static gen string2gen(String ss, boolean remove_ss_quotes) {
    return new gen(giacJNI.string2gen__SWIG_0(ss, remove_ss_quotes), true);
  }

  public static gen string2gen(String ss) {
    return new gen(giacJNI.string2gen__SWIG_1(ss), true);
  }

  public static gen no_context_evalf(gen e) {
    return new gen(giacJNI.no_context_evalf(gen.getCPtr(e), e), true);
  }

  public static gen evalf(gen e, int level, context contextptr) {
    return new gen(giacJNI.evalf(gen.getCPtr(e), e, level, context.getCPtr(contextptr), contextptr), true);
  }

  public static gen evalf2bcd_nock(gen g0, int level, context contextptr) {
    return new gen(giacJNI.evalf2bcd_nock(gen.getCPtr(g0), g0, level, context.getCPtr(contextptr), contextptr), true);
  }

  public static gen evalf2bcd(gen g0, int level, context contextptr) {
    return new gen(giacJNI.evalf2bcd(gen.getCPtr(g0), g0, level, context.getCPtr(contextptr), contextptr), true);
  }

  public static boolean has_evalf(gen g, gen res, int level, context contextptr) {
    return giacJNI.has_evalf(gen.getCPtr(g), g, gen.getCPtr(res), res, level, context.getCPtr(contextptr), contextptr);
  }

  public static double int2double(int i) {
    return giacJNI.int2double(i);
  }

  public static gen aplatir_fois_plus(gen g) {
    return new gen(giacJNI.aplatir_fois_plus(gen.getCPtr(g), g), true);
  }

  public static gen collect(gen g, context arg1) {
    return new gen(giacJNI.collect(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen select_root(SWIGTYPE_p_giac__vecteur v, context arg1) {
    return new gen(giacJNI.select_root(SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg1), arg1), true);
  }

  public static boolean is_known_rootof(SWIGTYPE_p_giac__vecteur v, gen symroot, context arg2) {
    return giacJNI.is_known_rootof(SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(symroot), symroot, context.getCPtr(arg2), arg2);
  }

  public static gen alg_evalf(gen a, gen b, context arg2) {
    return new gen(giacJNI.alg_evalf(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen approx_rootof(gen e, context arg1) {
    return new gen(giacJNI.approx_rootof(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen common_EXT(gen a, gen b, SWIGTYPE_p_giac__vecteur l, context arg3) {
    return new gen(giacJNI.common_EXT(gen.getCPtr(a), a, gen.getCPtr(b), b, SWIGTYPE_p_giac__vecteur.getCPtr(l), context.getCPtr(arg3), arg3), true);
  }

  public static gen common_minimal_POLY(gen ga, gen gb, gen a, gen b, SWIGTYPE_p_int k, context arg5) {
    return new gen(giacJNI.common_minimal_POLY(gen.getCPtr(ga), ga, gen.getCPtr(gb), gb, gen.getCPtr(a), a, gen.getCPtr(b), b, SWIGTYPE_p_int.getCPtr(k), context.getCPtr(arg5), arg5), true);
  }

  public static gen ext_add(gen a, gen b, context arg2) {
    return new gen(giacJNI.ext_add(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen ext_sub(gen a, gen b, context arg2) {
    return new gen(giacJNI.ext_sub(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen ext_mul(gen a, gen b, context arg2) {
    return new gen(giacJNI.ext_mul(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen symb_rootof(gen p, gen pmin, context arg2) {
    return new gen(giacJNI.symb_rootof(gen.getCPtr(p), p, gen.getCPtr(pmin), pmin, context.getCPtr(arg2), arg2), true);
  }

  public static gen rootof(gen e, context arg1) {
    return new gen(giacJNI.rootof(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur sturm(gen g, gen x, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.sturm(gen.getCPtr(g), g, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static int sturmab(gen g, gen x, gen a, gen b, context arg4) {
    return giacJNI.sturmab(gen.getCPtr(g), g, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg4), arg4);
  }

  public static gen _sturmab(gen g_orig, context arg1) {
    return new gen(giacJNI._sturmab(gen.getCPtr(g_orig), g_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sturm(gen g, context arg1) {
    return new gen(giacJNI._sturm(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sturmseq(gen g, context arg1) {
    return new gen(giacJNI._sturmseq(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static int sturmsign(gen a, boolean strict, context arg2) {
    return giacJNI.sturmsign(gen.getCPtr(a), a, strict, context.getCPtr(arg2), arg2);
  }

  public static int find_range(gen g, SWIGTYPE_p_giac__vecteur a, context arg2) {
    return giacJNI.find_range(gen.getCPtr(g), g, SWIGTYPE_p_giac__vecteur.getCPtr(a), context.getCPtr(arg2), arg2);
  }

  public static gen fminmax(gen g, int minmax, context arg2) {
    return new gen(giacJNI.fminmax(gen.getCPtr(g), g, minmax, context.getCPtr(arg2), arg2), true);
  }

  public static gen _complexroot(gen g, context arg1) {
    return new gen(giacJNI._complexroot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _realroot(gen g, context arg1) {
    return new gen(giacJNI._realroot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _crationalroot(gen g, context arg1) {
    return new gen(giacJNI._crationalroot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rationalroot(gen g, context arg1) {
    return new gen(giacJNI._rationalroot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur symb2poly_num(gen g, context arg1) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.symb2poly_num(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen eval_before_diff(gen expr, gen variable, context arg2) {
    return new gen(giacJNI.eval_before_diff(gen.getCPtr(expr), expr, gen.getCPtr(variable), variable, context.getCPtr(arg2), arg2), true);
  }

  public static gen derive(gen e, SWIGTYPE_p_giac__identificateur i, context arg2) {
    return new gen(giacJNI.derive__SWIG_0(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(i), context.getCPtr(arg2), arg2), true);
  }

  public static gen derive(gen e, gen vars, context arg2) {
    return new gen(giacJNI.derive__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(vars), vars, context.getCPtr(arg2), arg2), true);
  }

  public static gen derive(gen e, gen vars, gen nderiv, context arg3) {
    return new gen(giacJNI.derive__SWIG_2(gen.getCPtr(e), e, gen.getCPtr(vars), vars, gen.getCPtr(nderiv), nderiv, context.getCPtr(arg3), arg3), true);
  }

  public static gen _derive(gen args, context arg1) {
    return new gen(giacJNI._derive(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _function_diff(gen g, context arg1) {
    return new gen(giacJNI._function_diff(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _grad(gen args, context arg1) {
    return new gen(giacJNI._grad(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen laplace(gen f, gen x, gen s, context arg3) {
    return new gen(giacJNI.laplace(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(s), s, context.getCPtr(arg3), arg3), true);
  }

  public static gen _laplace(gen args, context arg1) {
    return new gen(giacJNI._laplace(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen diffeq_constante(int i, context arg1) {
    return new gen(giacJNI.diffeq_constante(i, context.getCPtr(arg1), arg1), true);
  }

  public static gen ilaplace(gen f, gen x, gen s, context arg3) {
    return new gen(giacJNI.ilaplace(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(s), s, context.getCPtr(arg3), arg3), true);
  }

  public static gen _ilaplace(gen args, context arg1) {
    return new gen(giacJNI._ilaplace(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _desolve(gen args, context arg1) {
    return new gen(giacJNI._desolve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen ztrans(gen f, gen x, gen s, context arg3) {
    return new gen(giacJNI.ztrans(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(s), s, context.getCPtr(arg3), arg3), true);
  }

  public static gen _ztrans(gen args, context arg1) {
    return new gen(giacJNI._ztrans(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen invztrans(gen f, gen x, gen s, context arg3) {
    return new gen(giacJNI.invztrans(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(s), s, context.getCPtr(arg3), arg3), true);
  }

  public static gen _invztrans(gen args, context arg1) {
    return new gen(giacJNI._invztrans(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen integrate_without_lnabs(gen e, gen x, context arg2) {
    return new gen(giacJNI.integrate_without_lnabs(gen.getCPtr(e), e, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _ezgcd(gen args, context arg1) {
    return new gen(giacJNI._ezgcd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _modgcd(gen args, context arg1) {
    return new gen(giacJNI._modgcd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _heugcd(gen args, context arg1) {
    return new gen(giacJNI._heugcd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _psrgcd(gen args, context arg1) {
    return new gen(giacJNI._psrgcd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur quad(SWIGTYPE_p_int b, gen q, SWIGTYPE_p_giac__vecteur x, context arg3) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.quad(SWIGTYPE_p_int.getCPtr(b), gen.getCPtr(q), q, SWIGTYPE_p_giac__vecteur.getCPtr(x), context.getCPtr(arg3), arg3), true);
  }

  public static SWIGTYPE_p_giac__vecteur qxa(gen q, SWIGTYPE_p_giac__vecteur x, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.qxa(gen.getCPtr(q), q, SWIGTYPE_p_giac__vecteur.getCPtr(x), context.getCPtr(arg2), arg2), true);
  }

  public static gen _q2a(gen args, context arg1) {
    return new gen(giacJNI._q2a(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur gauss(gen q, SWIGTYPE_p_giac__vecteur x, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.gauss(gen.getCPtr(q), q, SWIGTYPE_p_giac__vecteur.getCPtr(x), context.getCPtr(arg2), arg2), true);
  }

  public static gen _gauss(gen args, context arg1) {
    return new gen(giacJNI._gauss(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen axq(SWIGTYPE_p_giac__vecteur A, SWIGTYPE_p_giac__vecteur x, context arg2) {
    return new gen(giacJNI.axq(SWIGTYPE_p_giac__vecteur.getCPtr(A), SWIGTYPE_p_giac__vecteur.getCPtr(x), context.getCPtr(arg2), arg2), true);
  }

  public static gen _a2q(gen args, context arg1) {
    return new gen(giacJNI._a2q(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur qxac(gen q, SWIGTYPE_p_giac__vecteur x, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.qxac(gen.getCPtr(q), q, SWIGTYPE_p_giac__vecteur.getCPtr(x), context.getCPtr(arg2), arg2), true);
  }

  public static gen _conique_reduite(gen args, context arg1) {
    return new gen(giacJNI._conique_reduite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quadrique_reduite(gen args, context arg1) {
    return new gen(giacJNI._quadrique_reduite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static void settypeerr(context arg0) {
    giacJNI.settypeerr(context.getCPtr(arg0), arg0);
  }

  public static void setsizeerr(context arg0) {
    giacJNI.setsizeerr(context.getCPtr(arg0), arg0);
  }

  public static void setdimerr(context arg0) {
    giacJNI.setdimerr(context.getCPtr(arg0), arg0);
  }

  public static void divisionby0err(gen arg0, context arg1) {
    giacJNI.divisionby0err(gen.getCPtr(arg0), arg0, context.getCPtr(arg1), arg1);
  }

  public static void cksignerr(gen arg0, context arg1) {
    giacJNI.cksignerr(gen.getCPtr(arg0), arg0, context.getCPtr(arg1), arg1);
  }

  public static void invalidserieserr(String arg0, context arg1) {
    giacJNI.invalidserieserr(arg0, context.getCPtr(arg1), arg1);
  }

  public static void toofewargs(String s, context arg1) {
    giacJNI.toofewargs(s, context.getCPtr(arg1), arg1);
  }

  public static void toomanyargs(String s, context arg1) {
    giacJNI.toomanyargs(s, context.getCPtr(arg1), arg1);
  }

  public static void maxordererr(context arg0) {
    giacJNI.maxordererr(context.getCPtr(arg0), arg0);
  }

  public static void setstabilityerr(context arg0) {
    giacJNI.setstabilityerr(context.getCPtr(arg0), arg0);
  }

  public static gen gentypeerr(context arg0) {
    return new gen(giacJNI.gentypeerr__SWIG_0(context.getCPtr(arg0), arg0), true);
  }

  public static void gentypeerr(gen g, context arg1) {
    giacJNI.gentypeerr__SWIG_1(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static gen gensizeerr(context arg0) {
    return new gen(giacJNI.gensizeerr__SWIG_0(context.getCPtr(arg0), arg0), true);
  }

  public static void gensizeerr(gen g, context arg1) {
    giacJNI.gensizeerr__SWIG_1(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static gen gendimerr(context arg0) {
    return new gen(giacJNI.gendimerr__SWIG_0(context.getCPtr(arg0), arg0), true);
  }

  public static void gendimerr(gen g, context arg1) {
    giacJNI.gendimerr__SWIG_1(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static gen gendivisionby0err(gen arg0, context arg1) {
    return new gen(giacJNI.gendivisionby0err(gen.getCPtr(arg0), arg0, context.getCPtr(arg1), arg1), true);
  }

  public static gen gencksignerr(gen arg0, context arg1) {
    return new gen(giacJNI.gencksignerr(gen.getCPtr(arg0), arg0, context.getCPtr(arg1), arg1), true);
  }

  public static gen geninvalidserieserr(String arg0, context arg1) {
    return new gen(giacJNI.geninvalidserieserr(arg0, context.getCPtr(arg1), arg1), true);
  }

  public static gen gentoofewargs(String s, context arg1) {
    return new gen(giacJNI.gentoofewargs(s, context.getCPtr(arg1), arg1), true);
  }

  public static gen gentoomanyargs(String s, context arg1) {
    return new gen(giacJNI.gentoomanyargs(s, context.getCPtr(arg1), arg1), true);
  }

  public static gen genmaxordererr(context arg0) {
    return new gen(giacJNI.genmaxordererr(context.getCPtr(arg0), arg0), true);
  }

  public static gen genstabilityerr(context arg0) {
    return new gen(giacJNI.genstabilityerr(context.getCPtr(arg0), arg0), true);
  }

  public static String print_the_type(int val, context arg1) {
    return giacJNI.print_the_type(val, context.getCPtr(arg1), arg1);
  }

  public static String printinner_VECT(SWIGTYPE_p_giac__vecteur v, int subtype, context arg2) {
    return giacJNI.printinner_VECT(SWIGTYPE_p_giac__vecteur.getCPtr(v), subtype, context.getCPtr(arg2), arg2);
  }

  public static SWIGTYPE_p_std__string add_printinner_VECT(SWIGTYPE_p_std__string s, SWIGTYPE_p_giac__vecteur v, int subtype, context arg3) {
    return new SWIGTYPE_p_std__string(giacJNI.add_printinner_VECT(SWIGTYPE_p_std__string.getCPtr(s), SWIGTYPE_p_giac__vecteur.getCPtr(v), subtype, context.getCPtr(arg3), arg3), false);
  }

  public static String begin_VECT_string(int subtype, boolean tex, context arg2) {
    return giacJNI.begin_VECT_string(subtype, tex, context.getCPtr(arg2), arg2);
  }

  public static String end_VECT_string(int subtype, boolean tex, context arg2) {
    return giacJNI.end_VECT_string(subtype, tex, context.getCPtr(arg2), arg2);
  }

  public static String print_VECT(SWIGTYPE_p_giac__vecteur v, int subtype, context arg2) {
    return giacJNI.print_VECT(SWIGTYPE_p_giac__vecteur.getCPtr(v), subtype, context.getCPtr(arg2), arg2);
  }

  public static String printint32(int val, int subtype, context arg2) {
    return giacJNI.printint32(val, subtype, context.getCPtr(arg2), arg2);
  }

  public static String print_FLOAT_(SWIGTYPE_p_giac_float f, context arg1) {
    return giacJNI.print_FLOAT_(SWIGTYPE_p_giac_float.getCPtr(f), context.getCPtr(arg1), arg1);
  }

  public static gen parsed_gen(context arg0) {
    return new gen(giacJNI.parsed_gen__SWIG_0(context.getCPtr(arg0), arg0), true);
  }

  public static void parsed_gen(gen g, context arg1) {
    giacJNI.parsed_gen__SWIG_1(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static long archive_count(gen g, context arg1) {
    return giacJNI.archive_count(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static boolean archive_save(SWIGTYPE_p_void f, gen g, context arg2) {
    return giacJNI.archive_save(SWIGTYPE_p_void.getCPtr(f), gen.getCPtr(g), g, context.getCPtr(arg2), arg2);
  }

  public static gen archive_restore(SWIGTYPE_p_FILE f, context arg1) {
    return new gen(giacJNI.archive_restore(SWIGTYPE_p_FILE.getCPtr(f), context.getCPtr(arg1), arg1), true);
  }

  public static gen _ithprime(gen args, context arg1) {
    return new gen(giacJNI._ithprime(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ifactors(gen args, context arg1) {
    return new gen(giacJNI._ifactors(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _maple_ifactors(gen args, context arg1) {
    return new gen(giacJNI._maple_ifactors(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur ifactors(gen n0, context arg1) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.ifactors__SWIG_0(gen.getCPtr(n0), n0, context.getCPtr(arg1), arg1), true);
  }

  public static gen ifactors(gen args, int maplemode, context arg2) {
    return new gen(giacJNI.ifactors__SWIG_1(gen.getCPtr(args), args, maplemode, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur factors(gen g, gen x, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.factors(gen.getCPtr(g), g, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _factors(gen args, context arg1) {
    return new gen(giacJNI._factors(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _divis(gen args, context arg1) {
    return new gen(giacJNI._divis(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen idivis(gen n, context arg1) {
    return new gen(giacJNI.idivis(gen.getCPtr(n), n, context.getCPtr(arg1), arg1), true);
  }

  public static gen _idivis(gen args, context arg1) {
    return new gen(giacJNI._idivis(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur pfacprem(gen n, boolean addlast, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.pfacprem(gen.getCPtr(n), n, addlast, context.getCPtr(arg2), arg2), true);
  }

  public static gen ifactor(gen n, context arg1) {
    return new gen(giacJNI.ifactor(gen.getCPtr(n), n, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ifactor(gen args, context arg1) {
    return new gen(giacJNI._ifactor(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen euler(gen e, context arg1) {
    return new gen(giacJNI.euler(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _euler(gen args, context arg1) {
    return new gen(giacJNI._euler(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen pa2b2(gen p, context arg1) {
    return new gen(giacJNI.pa2b2(gen.getCPtr(p), p, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pa2b2(gen args, context arg1) {
    return new gen(giacJNI._pa2b2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _propfrac(gen args, context arg1) {
    return new gen(giacJNI._propfrac(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _iabcuv(gen args, context arg1) {
    return new gen(giacJNI._iabcuv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen abcuv(gen a, gen b, gen c, gen x, context arg4) {
    return new gen(giacJNI.abcuv(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(x), x, context.getCPtr(arg4), arg4), true);
  }

  public static gen _abcuv(gen args, context arg1) {
    return new gen(giacJNI._abcuv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen simp2(gen a, gen b, context arg2) {
    return new gen(giacJNI.simp2(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen _simp2(gen args, context arg1) {
    return new gen(giacJNI._simp2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fxnd(gen args, context arg1) {
    return new gen(giacJNI._fxnd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static int is_meromorphic(gen g, gen x, gen a, gen b, gen P, context arg5) {
    return giacJNI.is_meromorphic(gen.getCPtr(g), g, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(P), P, context.getCPtr(arg5), arg5);
  }

  public static int is_even_odd(gen f, gen x, context arg2) {
    return giacJNI.is_even_odd(gen.getCPtr(f), f, gen.getCPtr(x), x, context.getCPtr(arg2), arg2);
  }

  public static gen residue(gen g, gen x, gen a, context arg3) {
    return new gen(giacJNI.residue(gen.getCPtr(g), g, gen.getCPtr(x), x, gen.getCPtr(a), a, context.getCPtr(arg3), arg3), true);
  }

  public static gen _residue(gen args, context arg1) {
    return new gen(giacJNI._residue(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static boolean intgab(gen g, gen x, gen a, gen b, gen res, context arg5) {
    return giacJNI.intgab(gen.getCPtr(g), g, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(res), res, context.getCPtr(arg5), arg5);
  }

  public static SWIGTYPE_p_giac__vecteur singular(gen g, gen x, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.singular(gen.getCPtr(g), g, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _singular(gen args, context arg1) {
    return new gen(giacJNI._singular(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen complex_subst(gen e, SWIGTYPE_p_giac__vecteur substin, SWIGTYPE_p_giac__vecteur substout, context arg3) {
    return new gen(giacJNI.complex_subst__SWIG_0(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(substin), SWIGTYPE_p_giac__vecteur.getCPtr(substout), context.getCPtr(arg3), arg3), true);
  }

  public static gen complex_subst(gen e, gen x, gen newx, context arg3) {
    return new gen(giacJNI.complex_subst__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(newx), newx, context.getCPtr(arg3), arg3), true);
  }

  public static SWIGTYPE_p_giac__vecteur lvarxwithinv(gen e, gen x, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.lvarxwithinv(gen.getCPtr(e), e, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static boolean is_constant_wrt(gen e, gen x, context arg2) {
    return giacJNI.is_constant_wrt(gen.getCPtr(e), e, gen.getCPtr(x), x, context.getCPtr(arg2), arg2);
  }

  public static boolean is_linear_wrt(gen e, gen x, gen a, gen b, context arg4) {
    return giacJNI.is_linear_wrt(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg4), arg4);
  }

  public static boolean is_quadratic_wrt(gen e, gen x, gen a, gen b, gen c, context arg5) {
    return giacJNI.is_quadratic_wrt(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg5), arg5);
  }

  public static gen lnabs(gen x, context arg1) {
    return new gen(giacJNI.lnabs(gen.getCPtr(x), x, context.getCPtr(arg1), arg1), true);
  }

  public static gen surd(gen c, int n, context arg2) {
    return new gen(giacJNI.surd(gen.getCPtr(c), c, n, context.getCPtr(arg2), arg2), true);
  }

  public static gen _surd(gen args, context arg1) {
    return new gen(giacJNI._surd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen invexptoexpneg(gen g, context arg1) {
    return new gen(giacJNI.invexptoexpneg(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static boolean is_rewritable_as_f_of(gen fu, gen u, gen fx, gen gen_x, context arg4) {
    return giacJNI.is_rewritable_as_f_of(gen.getCPtr(fu), fu, gen.getCPtr(u), u, gen.getCPtr(fx), fx, gen.getCPtr(gen_x), gen_x, context.getCPtr(arg4), arg4);
  }

  public static boolean intgab_ratfrac(gen e, gen x, gen value, context arg3) {
    return giacJNI.intgab_ratfrac(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(value), value, context.getCPtr(arg3), arg3);
  }

  public static gen integrate_gen_rem(gen e, gen x, gen remains_to_integrate, context arg3) {
    return new gen(giacJNI.integrate_gen_rem(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(remains_to_integrate), remains_to_integrate, context.getCPtr(arg3), arg3), true);
  }

  public static gen integrate_id_rem(gen e, gen x, gen remains_to_integrate, context arg3) {
    return new gen(giacJNI.integrate_id_rem(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(remains_to_integrate), remains_to_integrate, context.getCPtr(arg3), arg3), true);
  }

  public static gen linear_integrate(gen e, gen x, gen remains_to_integrate, context arg3) {
    return new gen(giacJNI.linear_integrate(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(remains_to_integrate), remains_to_integrate, context.getCPtr(arg3), arg3), true);
  }

  public static gen integrate_id(gen e, SWIGTYPE_p_giac__identificateur x, context arg2) {
    return new gen(giacJNI.integrate_id(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), context.getCPtr(arg2), arg2), true);
  }

  public static gen integrate_gen(gen e, gen f, context arg2) {
    return new gen(giacJNI.integrate_gen(gen.getCPtr(e), e, gen.getCPtr(f), f, context.getCPtr(arg2), arg2), true);
  }

  public static gen _integrate(gen args, context arg1) {
    return new gen(giacJNI._integrate(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static double rombergo(gen f, gen x, gen a, gen b, int n, context arg5) {
    return giacJNI.rombergo(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, n, context.getCPtr(arg5), arg5);
  }

  public static double rombergt(gen f, gen x, gen a, gen b, int n, context arg5) {
    return giacJNI.rombergt(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, n, context.getCPtr(arg5), arg5);
  }

  public static gen _romberg(gen args, context arg1) {
    return new gen(giacJNI._romberg(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen sum(gen e, gen x, gen remains_to_sum, context arg3) {
    return new gen(giacJNI.sum__SWIG_0(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(remains_to_sum), remains_to_sum, context.getCPtr(arg3), arg3), true);
  }

  public static gen sum_loop(gen e, gen x, int i, int j, context arg4) {
    return new gen(giacJNI.sum_loop(gen.getCPtr(e), e, gen.getCPtr(x), x, i, j, context.getCPtr(arg4), arg4), true);
  }

  public static gen sum(gen e, gen x, gen a, gen b, context arg4) {
    return new gen(giacJNI.sum__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg4), arg4), true);
  }

  public static gen _sum(gen args, context arg1) {
    return new gen(giacJNI._sum(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Sum(gen args, context arg1) {
    return new gen(giacJNI._Sum(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _bernoulli(gen args, context arg1) {
    return new gen(giacJNI._bernoulli(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen seqprod(gen g, int type, context arg2) {
    return new gen(giacJNI.seqprod(gen.getCPtr(g), g, type, context.getCPtr(arg2), arg2), true);
  }

  public static gen _odesolve(gen args, context arg1) {
    return new gen(giacJNI._odesolve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen preval(gen f, gen x, gen a, gen b, context arg4) {
    return new gen(giacJNI.preval(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg4), arg4), true);
  }

  public static gen _ibpdv(gen args, context arg1) {
    return new gen(giacJNI._ibpdv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen fourier_an(gen f, gen x, gen T, gen n, gen a, context arg5) {
    return new gen(giacJNI.fourier_an(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(T), T, gen.getCPtr(n), n, gen.getCPtr(a), a, context.getCPtr(arg5), arg5), true);
  }

  public static gen fourier_bn(gen f, gen x, gen T, gen n, gen a, context arg5) {
    return new gen(giacJNI.fourier_bn(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(T), T, gen.getCPtr(n), n, gen.getCPtr(a), a, context.getCPtr(arg5), arg5), true);
  }

  public static gen fourier_cn(gen f, gen x, gen T, gen n, gen a, context arg5) {
    return new gen(giacJNI.fourier_cn(gen.getCPtr(f), f, gen.getCPtr(x), x, gen.getCPtr(T), T, gen.getCPtr(n), n, gen.getCPtr(a), a, context.getCPtr(arg5), arg5), true);
  }

  public static gen _fourier_an(gen args, context arg1) {
    return new gen(giacJNI._fourier_an(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fourier_bn(gen args, context arg1) {
    return new gen(giacJNI._fourier_bn(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fourier_cn(gen args, context arg1) {
    return new gen(giacJNI._fourier_cn(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _isom(gen args, context arg1) {
    return new gen(giacJNI._isom(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mkisom(gen args, context arg1) {
    return new gen(giacJNI._mkisom(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur mkisom(gen n, int b, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.mkisom(gen.getCPtr(n), n, b, context.getCPtr(arg2), arg2), true);
  }

  public static gen prod_expand(gen a, gen b, context arg2) {
    return new gen(giacJNI.prod_expand(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen unlin(SWIGTYPE_p_giac__vecteur v, context arg1) {
    return new gen(giacJNI.unlin(SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg1), arg1), true);
  }

  public static void convolution(gen coeff, gen arg, SWIGTYPE_p_giac__vecteur w, SWIGTYPE_p_giac__vecteur res, context arg4) {
    giacJNI.convolution(gen.getCPtr(coeff), coeff, gen.getCPtr(arg), arg, SWIGTYPE_p_giac__vecteur.getCPtr(w), SWIGTYPE_p_giac__vecteur.getCPtr(res), context.getCPtr(arg4), arg4);
  }

  public static void lin(gen e, SWIGTYPE_p_giac__vecteur v, context arg2) {
    giacJNI.lin(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg2), arg2);
  }

  public static gen _lin(gen e, context arg1) {
    return new gen(giacJNI._lin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen lnexpand(gen e, context arg1) {
    return new gen(giacJNI.lnexpand(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tunlin(SWIGTYPE_p_giac__vecteur v, context arg1) {
    return new gen(giacJNI.tunlin(SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg1), arg1), true);
  }

  public static void tconvolution(gen coeff, gen arg, SWIGTYPE_p_giac__vecteur w, SWIGTYPE_p_giac__vecteur res, context arg4) {
    giacJNI.tconvolution(gen.getCPtr(coeff), coeff, gen.getCPtr(arg), arg, SWIGTYPE_p_giac__vecteur.getCPtr(w), SWIGTYPE_p_giac__vecteur.getCPtr(res), context.getCPtr(arg4), arg4);
  }

  public static void tlin(gen e, SWIGTYPE_p_giac__vecteur v, context arg2) {
    giacJNI.tlin(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg2), arg2);
  }

  public static gen _tlin(gen e, context arg1) {
    return new gen(giacJNI._tlin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _texpand(gen e, context arg1) {
    return new gen(giacJNI._texpand(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen expand(gen e, context arg1) {
    return new gen(giacJNI.expand(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen ln_expand(gen e0, context arg1) {
    return new gen(giacJNI.ln_expand(gen.getCPtr(e0), e0, context.getCPtr(arg1), arg1), true);
  }

  public static gen expexpand(gen e, context arg1) {
    return new gen(giacJNI.expexpand(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen trigexpand(gen e, context arg1) {
    return new gen(giacJNI.trigexpand(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _about(gen g, context arg1) {
    return new gen(giacJNI._about(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _zip(gen args, context arg1) {
    return new gen(giacJNI._zip(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _accumulate_head_tail(gen args, context arg1) {
    return new gen(giacJNI._accumulate_head_tail(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _divide(gen g, context arg1) {
    return new gen(giacJNI._divide(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ratnormal(gen g, context arg1) {
    return new gen(giacJNI._ratnormal(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inverse(gen a_orig, context arg1) {
    return new gen(giacJNI._inverse(gen.getCPtr(a_orig), a_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Inverse(gen g, context arg1) {
    return new gen(giacJNI._Inverse(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _igcdex(gen a_orig, context arg1) {
    return new gen(giacJNI._igcdex(gen.getCPtr(a_orig), a_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _gcdex(gen a_orig, context arg1) {
    return new gen(giacJNI._gcdex(gen.getCPtr(a_orig), a_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _revlist(gen a, context arg1) {
    return new gen(giacJNI._revlist(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _restart(gen args, context arg1) {
    return new gen(giacJNI._restart(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _restart_modes(gen args, context arg1) {
    return new gen(giacJNI._restart_modes(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _time(gen a, context arg1) {
    return new gen(giacJNI._time(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cat(gen a_orig, context arg1) {
    return new gen(giacJNI._cat(gen.getCPtr(a_orig), a_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pivot(gen a_orig, context arg1) {
    return new gen(giacJNI._pivot(gen.getCPtr(a_orig), a_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rowspace(gen g, context arg1) {
    return new gen(giacJNI._rowspace(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _colspace(gen g, context arg1) {
    return new gen(giacJNI._colspace(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _copy(gen g, context arg1) {
    return new gen(giacJNI._copy(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _row(gen g, context arg1) {
    return new gen(giacJNI._row(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _col(gen g, context arg1) {
    return new gen(giacJNI._col(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _count_sup(gen args, context arg1) {
    return new gen(giacJNI._count_sup(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _count_inf(gen args, context arg1) {
    return new gen(giacJNI._count_inf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _trunc(gen args, context arg1) {
    return new gen(giacJNI._trunc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _evalc(gen g, context arg1) {
    return new gen(giacJNI._evalc(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _open(gen g, context arg1) {
    return new gen(giacJNI._open(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fopen(gen g, context arg1) {
    return new gen(giacJNI._fopen(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fprint(gen g, context arg1) {
    return new gen(giacJNI._fprint(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _close(gen g, context arg1) {
    return new gen(giacJNI._close(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _blockmatrix(gen g, context arg1) {
    return new gen(giacJNI._blockmatrix(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _delcols(gen g, context arg1) {
    return new gen(giacJNI._delcols(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _delrows(gen g, context arg1) {
    return new gen(giacJNI._delrows(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _JordanBlock(gen g, context arg1) {
    return new gen(giacJNI._JordanBlock(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _companion(gen g, context arg1) {
    return new gen(giacJNI._companion(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _border(gen g, context arg1) {
    return new gen(giacJNI._border(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pade(gen g, context arg1) {
    return new gen(giacJNI._pade(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lhs(gen g, context arg1) {
    return new gen(giacJNI._lhs(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rhs(gen g, context arg1) {
    return new gen(giacJNI._rhs(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _reverse_rsolve(gen g, context arg1) {
    return new gen(giacJNI._reverse_rsolve(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen fft(gen g_orig, int direct, context arg2) {
    return new gen(giacJNI.fft(gen.getCPtr(g_orig), g_orig, direct, context.getCPtr(arg2), arg2), true);
  }

  public static gen _fft(gen g, context arg1) {
    return new gen(giacJNI._fft(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ifft(gen g, context arg1) {
    return new gen(giacJNI._ifft(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Resultant(gen g, context arg1) {
    return new gen(giacJNI._Resultant(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Nullspace(gen g, context arg1) {
    return new gen(giacJNI._Nullspace(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _assign(gen g, context arg1) {
    return new gen(giacJNI._assign(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _implicitplot3d(gen g, context arg1) {
    return new gen(giacJNI._implicitplot3d(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _readwav(gen g, context arg1) {
    return new gen(giacJNI._readwav(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _writewav(gen g, context arg1) {
    return new gen(giacJNI._writewav(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _animate(gen g, context arg1) {
    return new gen(giacJNI._animate(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _animate3d(gen g, context arg1) {
    return new gen(giacJNI._animate3d(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _even(gen g, context arg1) {
    return new gen(giacJNI._even(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _odd(gen g, context arg1) {
    return new gen(giacJNI._odd(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _writergb(gen g, context arg1) {
    return new gen(giacJNI._writergb(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _readrgb(gen g, context arg1) {
    return new gen(giacJNI._readrgb(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen product(SWIGTYPE_p_giac__polynome P, SWIGTYPE_p_giac__vecteur v, gen n, gen remains, context arg4) {
    return new gen(giacJNI.product(SWIGTYPE_p_giac__polynome.getCPtr(P), SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(n), n, gen.getCPtr(remains), remains, context.getCPtr(arg4), arg4), true);
  }

  public static gen _seqsolve(gen args, context arg1) {
    return new gen(giacJNI._seqsolve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rsolve(gen args, context arg1) {
    return new gen(giacJNI._rsolve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _array(gen g, context arg1) {
    return new gen(giacJNI._array(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _makemod(gen args, context arg1) {
    return new gen(giacJNI._makemod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hexprint(gen g, context arg1) {
    return new gen(giacJNI._hexprint(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _octprint(gen g, context arg1) {
    return new gen(giacJNI._octprint(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _binprint(gen g, context arg1) {
    return new gen(giacJNI._binprint(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static String cprint(gen args, context arg1) {
    return giacJNI.cprint(gen.getCPtr(args), args, context.getCPtr(arg1), arg1);
  }

  public static gen _mathml(gen g, context arg1) {
    return new gen(giacJNI._mathml(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _spread2mathml(gen g, context arg1) {
    return new gen(giacJNI._spread2mathml(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static String gen2mathml(gen e, context arg1) {
    return giacJNI.gen2mathml__SWIG_0(gen.getCPtr(e), e, context.getCPtr(arg1), arg1);
  }

  public static String gen2mathml(gen e, SWIGTYPE_p_std__string svg, context arg2) {
    return giacJNI.gen2mathml__SWIG_1(gen.getCPtr(e), e, SWIGTYPE_p_std__string.getCPtr(svg), context.getCPtr(arg2), arg2);
  }

  public static String gen2svg(gen e, context arg1) {
    return giacJNI.gen2svg(gen.getCPtr(e), e, context.getCPtr(arg1), arg1);
  }

  public static gen _scalar_product(gen args, context arg1) {
    return new gen(giacJNI._scalar_product(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _compare(gen args, context arg1) {
    return new gen(giacJNI._compare(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _preval(gen args, context arg1) {
    return new gen(giacJNI._preval(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lagrange(gen args, context arg1) {
    return new gen(giacJNI._lagrange(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _reorder(gen args, context arg1) {
    return new gen(giacJNI._reorder(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _adjoint_matrix(gen args, context arg1) {
    return new gen(giacJNI._adjoint_matrix(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _equal2diff(gen args, context arg1) {
    return new gen(giacJNI._equal2diff(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _equal2list(gen args, context arg1) {
    return new gen(giacJNI._equal2list(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rank(gen args, context arg1) {
    return new gen(giacJNI._rank(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _csc(gen args, context arg1) {
    return new gen(giacJNI._csc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cot(gen args, context arg1) {
    return new gen(giacJNI._cot(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _acsc(gen args, context arg1) {
    return new gen(giacJNI._acsc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ibpu(gen args, context arg1) {
    return new gen(giacJNI._ibpu(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _changebase(gen args, context arg1) {
    return new gen(giacJNI._changebase(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _epsilon2zero(gen args, context arg1) {
    return new gen(giacJNI._epsilon2zero(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _suppress(gen args, context arg1) {
    return new gen(giacJNI._suppress(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _valuation(gen args, context arg1) {
    return new gen(giacJNI._valuation(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _degree(gen args, context arg1) {
    return new gen(giacJNI._degree(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lcoeff(gen args, context arg1) {
    return new gen(giacJNI._lcoeff(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tcoeff(gen args, context arg1) {
    return new gen(giacJNI._tcoeff(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sqrfree(gen args, context arg1) {
    return new gen(giacJNI._sqrfree(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _truncate(gen args, context arg1) {
    return new gen(giacJNI._truncate(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _canonical_form(gen args, context arg1) {
    return new gen(giacJNI._canonical_form(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fcoeff(gen args, context arg1) {
    return new gen(giacJNI._fcoeff(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _froot(gen args, context arg1) {
    return new gen(giacJNI._froot(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _roots(gen g, context arg1) {
    return new gen(giacJNI._roots(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _divpc(gen args, context arg1) {
    return new gen(giacJNI._divpc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ptayl(gen args, context arg1) {
    return new gen(giacJNI._ptayl(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dfc(gen g_orig, context arg1) {
    return new gen(giacJNI._dfc(gen.getCPtr(g_orig), g_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dfc2f(gen g, context arg1) {
    return new gen(giacJNI._dfc2f(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _float2rational(gen g, context arg1) {
    return new gen(giacJNI._float2rational(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _gramschmidt(gen g, context arg1) {
    return new gen(giacJNI._gramschmidt(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pmin(gen g, context arg1) {
    return new gen(giacJNI._pmin(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _potential(gen g, context arg1) {
    return new gen(giacJNI._potential(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _vpotential(gen g, context arg1) {
    return new gen(giacJNI._vpotential(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _poly2symb(gen g, context arg1) {
    return new gen(giacJNI._poly2symb(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _symb2poly(gen g, context arg1) {
    return new gen(giacJNI._symb2poly(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _exp2trig(gen g, context arg1) {
    return new gen(giacJNI._exp2trig(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _nrows(gen g, context arg1) {
    return new gen(giacJNI._nrows(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ncols(gen g, context arg1) {
    return new gen(giacJNI._ncols(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _l2norm(gen g0, context arg1) {
    return new gen(giacJNI._l2norm(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _normalize(gen a, context arg1) {
    return new gen(giacJNI._normalize(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lgcd(gen g, context arg1) {
    return new gen(giacJNI._lgcd(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _float(gen g, context arg1) {
    return new gen(giacJNI._float(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hold(gen g, context arg1) {
    return new gen(giacJNI._hold(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _eigenvals(gen g, context arg1) {
    return new gen(giacJNI._eigenvals(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Gcd(gen g, context arg1) {
    return new gen(giacJNI._Gcd(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Gcdex(gen g, context arg1) {
    return new gen(giacJNI._Gcdex(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Factor(gen g, context arg1) {
    return new gen(giacJNI._Factor(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Rref(gen g, context arg1) {
    return new gen(giacJNI._Rref(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Rank(gen g, context arg1) {
    return new gen(giacJNI._Rank(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Det(gen g, context arg1) {
    return new gen(giacJNI._Det(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Quo(gen g, context arg1) {
    return new gen(giacJNI._Quo(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Rem(gen g, context arg1) {
    return new gen(giacJNI._Rem(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Int(gen g, context arg1) {
    return new gen(giacJNI._Int(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _divisors(gen g, context arg1) {
    return new gen(giacJNI._divisors(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _maxnorm(gen g0, context arg1) {
    return new gen(giacJNI._maxnorm(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _l1norm(gen g0, context arg1) {
    return new gen(giacJNI._l1norm(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dotprod(gen g, context arg1) {
    return new gen(giacJNI._dotprod(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _diag(gen g, context arg1) {
    return new gen(giacJNI._diag(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _input(gen args, context arg1) {
    return new gen(giacJNI._input__SWIG_0(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _textinput(gen args, context arg1) {
    return new gen(giacJNI._textinput(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _primpart(gen g, context arg1) {
    return new gen(giacJNI._primpart(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _content(gen g, context arg1) {
    return new gen(giacJNI._content(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _coeff(gen g, context arg1) {
    return new gen(giacJNI._coeff(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _chrem(gen g, context arg1) {
    return new gen(giacJNI._chrem(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _genpoly(gen g, context arg1) {
    return new gen(giacJNI._genpoly(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _median(gen g, context arg1) {
    return new gen(giacJNI._median(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quartile1(gen g, context arg1) {
    return new gen(giacJNI._quartile1(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quartile3(gen g, context arg1) {
    return new gen(giacJNI._quartile3(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quantile(gen g, context arg1) {
    return new gen(giacJNI._quantile(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quartiles(gen g, context arg1) {
    return new gen(giacJNI._quartiles(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _moustache(gen g_orig, context arg1) {
    return new gen(giacJNI._moustache(gen.getCPtr(g_orig), g_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mean(gen g, context arg1) {
    return new gen(giacJNI._mean(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _stdDev(gen g, context arg1) {
    return new gen(giacJNI._stdDev(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _stddev(gen g, context arg1) {
    return new gen(giacJNI._stddev(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _variance(gen g, context arg1) {
    return new gen(giacJNI._variance(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _covariance_correlation(gen g, context arg1) {
    return new gen(giacJNI._covariance_correlation(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _covariance(gen g, context arg1) {
    return new gen(giacJNI._covariance(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _correlation(gen g, context arg1) {
    return new gen(giacJNI._correlation(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _interval2center(gen g, context arg1) {
    return new gen(giacJNI._interval2center(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _linear_regression(gen g, context arg1) {
    return new gen(giacJNI._linear_regression(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _exponential_regression(gen g, context arg1) {
    return new gen(giacJNI._exponential_regression(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _power_regression(gen g, context arg1) {
    return new gen(giacJNI._power_regression(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen regression_plot_attributs(gen g, SWIGTYPE_p_giac__vecteur attributs, SWIGTYPE_p_bool eq, SWIGTYPE_p_bool r, context arg4) {
    return new gen(giacJNI.regression_plot_attributs(gen.getCPtr(g), g, SWIGTYPE_p_giac__vecteur.getCPtr(attributs), SWIGTYPE_p_bool.getCPtr(eq), SWIGTYPE_p_bool.getCPtr(r), context.getCPtr(arg4), arg4), true);
  }

  public static gen _linear_regression_plot(gen g, context arg1) {
    return new gen(giacJNI._linear_regression_plot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _exponential_regression_plot(gen g, context arg1) {
    return new gen(giacJNI._exponential_regression_plot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _logarithmic_regression_plot(gen g, context arg1) {
    return new gen(giacJNI._logarithmic_regression_plot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _power_regression_plot(gen g, context arg1) {
    return new gen(giacJNI._power_regression_plot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polynomial_regression(gen g, context arg1) {
    return new gen(giacJNI._polynomial_regression(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polynomial_regression_plot(gen g, context arg1) {
    return new gen(giacJNI._polynomial_regression_plot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _logistic_regression(gen g, context arg1) {
    return new gen(giacJNI._logistic_regression(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _logistic_regression_plot(gen g, context arg1) {
    return new gen(giacJNI._logistic_regression_plot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _linear_interpolate(gen g, context arg1) {
    return new gen(giacJNI._linear_interpolate(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _parabolic_interpolate(gen g, context arg1) {
    return new gen(giacJNI._parabolic_interpolate(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _center2interval(gen g, context arg1) {
    return new gen(giacJNI._center2interval(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _histogram(gen g, context arg1) {
    return new gen(giacJNI._histogram(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cumulated_frequencies(gen g, context arg1) {
    return new gen(giacJNI._cumulated_frequencies(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _classes(gen g, context arg1) {
    return new gen(giacJNI._classes(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _listplot(gen g, context arg1) {
    return new gen(giacJNI._listplot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _scatterplot(gen g, context arg1) {
    return new gen(giacJNI._scatterplot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polygonplot(gen g, context arg1) {
    return new gen(giacJNI._polygonplot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polygonscatterplot(gen g, context arg1) {
    return new gen(giacJNI._polygonscatterplot(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _diagramme_batons(gen g, context arg1) {
    return new gen(giacJNI._diagramme_batons(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _camembert(gen g, context arg1) {
    return new gen(giacJNI._camembert(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen cross_prod(gen a, gen b, gen c, context arg3) {
    return new gen(giacJNI.cross_prod(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg3), arg3), true);
  }

  public static gen _convexhull(gen g, context arg1) {
    return new gen(giacJNI._convexhull(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _simplex_reduce(gen g, context arg1) {
    return new gen(giacJNI._simplex_reduce(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _spline(gen g, context arg1) {
    return new gen(giacJNI._spline(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _bitand(gen g, context arg1) {
    return new gen(giacJNI._bitand(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _bitor(gen g, context arg1) {
    return new gen(giacJNI._bitor(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _bitxor(gen g, context arg1) {
    return new gen(giacJNI._bitxor(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hamdist(gen g, context arg1) {
    return new gen(giacJNI._hamdist(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotarea(gen g, context arg1) {
    return new gen(giacJNI._plotarea(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _add_language(gen args, context arg1) {
    return new gen(giacJNI._add_language(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _remove_language(gen args, context arg1) {
    return new gen(giacJNI._remove_language(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _show_language(gen args, context arg1) {
    return new gen(giacJNI._show_language(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _os_version(gen args, context arg1) {
    return new gen(giacJNI._os_version(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur gen2continued_fraction(gen g, int n, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.gen2continued_fraction(gen.getCPtr(g), g, n, context.getCPtr(arg2), arg2), true);
  }

  public static gen float2rational(double d_orig, double eps, context arg2) {
    return new gen(giacJNI.float2rational(d_orig, eps, context.getCPtr(arg2), arg2), true);
  }

  public static gen _sec(gen args, context arg1) {
    return new gen(giacJNI._sec(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _asec(gen args, context arg1) {
    return new gen(giacJNI._asec(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _acot(gen args, context arg1) {
    return new gen(giacJNI._acot(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _horner(gen args, context arg1) {
    return new gen(giacJNI._horner(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _moyal(gen args, context arg1) {
    return new gen(giacJNI._moyal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Airy_Ai(gen args, context arg1) {
    return new gen(giacJNI._Airy_Ai(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Airy_Bi(gen args, context arg1) {
    return new gen(giacJNI._Airy_Bi(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _randNorm(gen args, context arg1) {
    return new gen(giacJNI._randNorm(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _randexp(gen args, context arg1) {
    return new gen(giacJNI._randexp(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _UTPN(gen args, context arg1) {
    return new gen(giacJNI._UTPN(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen UTPC(gen n_orig, gen x0, context arg2) {
    return new gen(giacJNI.UTPC(gen.getCPtr(n_orig), n_orig, gen.getCPtr(x0), x0, context.getCPtr(arg2), arg2), true);
  }

  public static gen _UTPC(gen args, context arg1) {
    return new gen(giacJNI._UTPC(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen UTPT(gen n_orig, gen x0, context arg2) {
    return new gen(giacJNI.UTPT(gen.getCPtr(n_orig), n_orig, gen.getCPtr(x0), x0, context.getCPtr(arg2), arg2), true);
  }

  public static gen _UTPT(gen args, context arg1) {
    return new gen(giacJNI._UTPT(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen UTPF(gen num, gen den, gen x0, context arg3) {
    return new gen(giacJNI.UTPF(gen.getCPtr(num), num, gen.getCPtr(den), den, gen.getCPtr(x0), x0, context.getCPtr(arg3), arg3), true);
  }

  public static gen _UTPF(gen args, context arg1) {
    return new gen(giacJNI._UTPF(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen binomial(gen n, gen k, gen p, context arg3) {
    return new gen(giacJNI.binomial(gen.getCPtr(n), n, gen.getCPtr(k), k, gen.getCPtr(p), p, context.getCPtr(arg3), arg3), true);
  }

  public static gen _binomial(gen args, context arg1) {
    return new gen(giacJNI._binomial(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen binomial_cdf(gen n, gen p, gen x0, gen x, context arg4) {
    return new gen(giacJNI.binomial_cdf(gen.getCPtr(n), n, gen.getCPtr(p), p, gen.getCPtr(x0), x0, gen.getCPtr(x), x, context.getCPtr(arg4), arg4), true);
  }

  public static gen _binomial_cdf(gen args, context arg1) {
    return new gen(giacJNI._binomial_cdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen binomial_icdf(gen n, gen p, gen x_orig, context arg3) {
    return new gen(giacJNI.binomial_icdf(gen.getCPtr(n), n, gen.getCPtr(p), p, gen.getCPtr(x_orig), x_orig, context.getCPtr(arg3), arg3), true);
  }

  public static gen _binomial_icdf(gen args, context arg1) {
    return new gen(giacJNI._binomial_icdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen poisson(gen m, gen k, context arg2) {
    return new gen(giacJNI.poisson(gen.getCPtr(m), m, gen.getCPtr(k), k, context.getCPtr(arg2), arg2), true);
  }

  public static gen _poisson(gen args, context arg1) {
    return new gen(giacJNI._poisson(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen poisson_cdf(gen n, gen x, context arg2) {
    return new gen(giacJNI.poisson_cdf(gen.getCPtr(n), n, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _poisson_cdf(gen args, context arg1) {
    return new gen(giacJNI._poisson_cdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen poisson_icdf(gen m, gen t_orig, context arg2) {
    return new gen(giacJNI.poisson_icdf(gen.getCPtr(m), m, gen.getCPtr(t_orig), t_orig, context.getCPtr(arg2), arg2), true);
  }

  public static gen _poisson_icdf(gen args, context arg1) {
    return new gen(giacJNI._poisson_icdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _normald(gen g, context arg1) {
    return new gen(giacJNI._normald(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _normal_cdf(gen args, context arg1) {
    return new gen(giacJNI._normal_cdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _normal_icdf(gen args, context arg1) {
    return new gen(giacJNI._normal_icdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen student(gen n, gen x, context arg2) {
    return new gen(giacJNI.student(gen.getCPtr(n), n, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _student(gen args, context arg1) {
    return new gen(giacJNI._student(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen student_cdf(gen dof, gen x1, gen x2, context arg3) {
    return new gen(giacJNI.student_cdf(gen.getCPtr(dof), dof, gen.getCPtr(x1), x1, gen.getCPtr(x2), x2, context.getCPtr(arg3), arg3), true);
  }

  public static gen _student_cdf(gen args, context arg1) {
    return new gen(giacJNI._student_cdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen student_icdf(gen m, gen t_orig, context arg2) {
    return new gen(giacJNI.student_icdf(gen.getCPtr(m), m, gen.getCPtr(t_orig), t_orig, context.getCPtr(arg2), arg2), true);
  }

  public static gen _student_icdf(gen args, context arg1) {
    return new gen(giacJNI._student_icdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen chisquare(gen n, gen x, context arg2) {
    return new gen(giacJNI.chisquare(gen.getCPtr(n), n, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _chisquare(gen args, context arg1) {
    return new gen(giacJNI._chisquare(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen chisquare_cdf(gen dof, gen x1, gen x2, context arg3) {
    return new gen(giacJNI.chisquare_cdf(gen.getCPtr(dof), dof, gen.getCPtr(x1), x1, gen.getCPtr(x2), x2, context.getCPtr(arg3), arg3), true);
  }

  public static gen _chisquare_cdf(gen args, context arg1) {
    return new gen(giacJNI._chisquare_cdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen chisquare_icdf(gen m, gen t_orig, context arg2) {
    return new gen(giacJNI.chisquare_icdf(gen.getCPtr(m), m, gen.getCPtr(t_orig), t_orig, context.getCPtr(arg2), arg2), true);
  }

  public static gen _chisquare_icdf(gen args, context arg1) {
    return new gen(giacJNI._chisquare_icdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen snedecor(gen a, gen b, gen x, context arg3) {
    return new gen(giacJNI.snedecor(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(x), x, context.getCPtr(arg3), arg3), true);
  }

  public static gen _snedecor(gen args, context arg1) {
    return new gen(giacJNI._snedecor(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen snedecor_cdf(gen ndof, gen ddof, gen x, context arg3) {
    return new gen(giacJNI.snedecor_cdf(gen.getCPtr(ndof), ndof, gen.getCPtr(ddof), ddof, gen.getCPtr(x), x, context.getCPtr(arg3), arg3), true);
  }

  public static gen _snedecor_cdf(gen args, context arg1) {
    return new gen(giacJNI._snedecor_cdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen snedecor_icdf(gen num, gen den, gen t_orig, context arg3) {
    return new gen(giacJNI.snedecor_icdf(gen.getCPtr(num), num, gen.getCPtr(den), den, gen.getCPtr(t_orig), t_orig, context.getCPtr(arg3), arg3), true);
  }

  public static gen _snedecor_icdf(gen args, context arg1) {
    return new gen(giacJNI._snedecor_icdf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen Beta(gen a, gen b, context arg2) {
    return new gen(giacJNI.Beta(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen _Beta(gen args, context arg1) {
    return new gen(giacJNI._Beta(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen Bessel(gen g, int kind, context arg2) {
    return new gen(giacJNI.Bessel(gen.getCPtr(g), g, kind, context.getCPtr(arg2), arg2), true);
  }

  public static gen _BesselI(gen args, context arg1) {
    return new gen(giacJNI._BesselI(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _BesselJ(gen args, context arg1) {
    return new gen(giacJNI._BesselJ(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _BesselK(gen args, context arg1) {
    return new gen(giacJNI._BesselK(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _BesselY(gen args, context arg1) {
    return new gen(giacJNI._BesselY(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _constants_catalog(gen g, context arg1) {
    return new gen(giacJNI._constants_catalog(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pari(gen args, context arg1) {
    return new gen(giacJNI._pari(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _trn(gen args, context arg1) {
    return new gen(giacJNI._trn(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sizes(gen args, context arg1) {
    return new gen(giacJNI._sizes(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _permuorder(gen args, context arg1) {
    return new gen(giacJNI._permuorder(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _randperm(gen args, context arg1) {
    return new gen(giacJNI._randperm(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _is_permu(gen args, context arg1) {
    return new gen(giacJNI._is_permu(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _is_cycle(gen args, context arg1) {
    return new gen(giacJNI._is_cycle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cycle2perm(gen args, context arg1) {
    return new gen(giacJNI._cycle2perm(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _p1op2(gen args, context arg1) {
    return new gen(giacJNI._p1op2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _c1oc2(gen args, context arg1) {
    return new gen(giacJNI._c1oc2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _c1op2(gen args, context arg1) {
    return new gen(giacJNI._c1op2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _p1oc2(gen args, context arg1) {
    return new gen(giacJNI._p1oc2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cycles2permu(gen args, context arg1) {
    return new gen(giacJNI._cycles2permu(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _permu2cycles(gen args, context arg1) {
    return new gen(giacJNI._permu2cycles(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _perminv(gen args, context arg1) {
    return new gen(giacJNI._perminv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cycleinv(gen args, context arg1) {
    return new gen(giacJNI._cycleinv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _signature(gen args, context arg1) {
    return new gen(giacJNI._signature(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hilbert(gen args, context arg1) {
    return new gen(giacJNI._hilbert(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hadamard(gen args, context arg1) {
    return new gen(giacJNI._hadamard(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _syst2mat(gen args, context arg1) {
    return new gen(giacJNI._syst2mat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _vandermonde(gen args, context arg1) {
    return new gen(giacJNI._vandermonde(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _laplacian(gen args, context arg1) {
    return new gen(giacJNI._laplacian(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hessian(gen args, context arg1) {
    return new gen(giacJNI._hessian(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _divergence(gen args, context arg1) {
    return new gen(giacJNI._divergence(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _curl(gen args, context arg1) {
    return new gen(giacJNI._curl(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _groupermu(gen args, context arg1) {
    return new gen(giacJNI._groupermu(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _nextperm(gen args, context arg1) {
    return new gen(giacJNI._nextperm(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _prevperm(gen args, context arg1) {
    return new gen(giacJNI._prevperm(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _split(gen args, context arg1) {
    return new gen(giacJNI._split(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sum_riemann(gen args, context arg1) {
    return new gen(giacJNI._sum_riemann(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hermite(gen args, context arg1) {
    return new gen(giacJNI._hermite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _laguerre(gen args, context arg1) {
    return new gen(giacJNI._laguerre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tchebyshev1(gen args, context arg1) {
    return new gen(giacJNI._tchebyshev1(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tchebyshev2(gen args, context arg1) {
    return new gen(giacJNI._tchebyshev2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _legendre(gen args, context arg1) {
    return new gen(giacJNI._legendre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _permu2mat(gen args, context arg1) {
    return new gen(giacJNI._permu2mat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur interpolyedre(SWIGTYPE_p_giac__vecteur p, gen bb, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.interpolyedre(SWIGTYPE_p_giac__vecteur.getCPtr(p), gen.getCPtr(bb), bb, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur interdroitehyperplan(gen a, gen b, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.interdroitehyperplan(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur interhyperplan(gen p1, gen p2, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.interhyperplan(gen.getCPtr(p1), p1, gen.getCPtr(p2), p2, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur interhypersurfacecurve(gen a, gen b, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.interhypersurfacecurve(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur inter2hypersurface(gen a, gen b, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.inter2hypersurface(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur interplansphere(gen a, gen b, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.interplansphere(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen hypersurface_equation(gen g, SWIGTYPE_p_giac__vecteur xyz, context arg2) {
    return new gen(giacJNI.hypersurface_equation(gen.getCPtr(g), g, SWIGTYPE_p_giac__vecteur.getCPtr(xyz), context.getCPtr(arg2), arg2), true);
  }

  public static gen _plot3d(gen args, context arg1) {
    return new gen(giacJNI._plot3d(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hypersurface(gen args, context arg1) {
    return new gen(giacJNI._hypersurface(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hyperplan(gen args, context arg1) {
    return new gen(giacJNI._hyperplan(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plan(gen args, context arg1) {
    return new gen(giacJNI._plan(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cone(gen args, context arg1) {
    return new gen(giacJNI._cone(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _demi_cone(gen args, context arg1) {
    return new gen(giacJNI._demi_cone(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cylindre(gen args, context arg1) {
    return new gen(giacJNI._cylindre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _perpendiculaire_commune(gen args, context arg1) {
    return new gen(giacJNI._perpendiculaire_commune(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polyedre(gen args, context arg1) {
    return new gen(giacJNI._polyedre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _prisme(gen args, context arg1) {
    return new gen(giacJNI._prisme(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _parallelepipede(gen args, context arg1) {
    return new gen(giacJNI._parallelepipede(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pyramide(gen args, context arg1) {
    return new gen(giacJNI._pyramide(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tetraedre_centre(gen args, context arg1) {
    return new gen(giacJNI._tetraedre_centre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cube(gen args, context arg1) {
    return new gen(giacJNI._cube(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cube_centre(gen args, context arg1) {
    return new gen(giacJNI._cube_centre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _octaedre(gen args, context arg1) {
    return new gen(giacJNI._octaedre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _icosaedre(gen args, context arg1) {
    return new gen(giacJNI._icosaedre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dodecaedre(gen args, context arg1) {
    return new gen(giacJNI._dodecaedre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _aretes(gen args, context arg1) {
    return new gen(giacJNI._aretes(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _faces(gen args, context arg1) {
    return new gen(giacJNI._faces(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hypersphere(gen args, context arg1) {
    return new gen(giacJNI._hypersphere(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sphere(gen args, context arg1) {
    return new gen(giacJNI._sphere(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quadrique(gen args, context arg1) {
    return new gen(giacJNI._quadrique(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_cospherique(gen args, context arg1) {
    return new gen(giacJNI._est_cospherique(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen get_point(gen g, int n, context arg2) {
    return new gen(giacJNI.get_point(gen.getCPtr(g), g, n, context.getCPtr(arg2), arg2), true);
  }

  public static gen _point3d(gen args, context arg1) {
    return new gen(giacJNI._point3d(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _point2d(gen args, context arg1) {
    return new gen(giacJNI._point2d(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen mkrand2d3d(int dim, int nargs, SWIGTYPE_p_f_r_q_const__giac__gen_p_q_const__giac__context__giac__gen f, context arg3) {
    return new gen(giacJNI.mkrand2d3d(dim, nargs, SWIGTYPE_p_f_r_q_const__giac__gen_p_q_const__giac__context__giac__gen.getCPtr(f), context.getCPtr(arg3), arg3), true);
  }

  public static gen droite_by_equation(SWIGTYPE_p_giac__vecteur v, boolean est_plan, context arg2) {
    return new gen(giacJNI.droite_by_equation(SWIGTYPE_p_giac__vecteur.getCPtr(v), est_plan, context.getCPtr(arg2), arg2), true);
  }

  public static boolean point2abc(gen e, gen f, gen a, gen b, gen c, context arg5) {
    return giacJNI.point2abc(gen.getCPtr(e), e, gen.getCPtr(f), f, gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg5), arg5);
  }

  public static gen abs_norm(gen g, context arg1) {
    return new gen(giacJNI.abs_norm(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen abs_norm2(gen g, context arg1) {
    return new gen(giacJNI.abs_norm2(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur interpolygone(SWIGTYPE_p_giac__vecteur p, gen bb, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.interpolygone(SWIGTYPE_p_giac__vecteur.getCPtr(p), gen.getCPtr(bb), bb, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur interdroitecercle(gen a, gen b, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.interdroitecercle(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur curveintercircle(gen curve, gen circle, boolean iscircle, context arg3) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.curveintercircle(gen.getCPtr(curve), curve, gen.getCPtr(circle), circle, iscircle, context.getCPtr(arg3), arg3), true);
  }

  public static gen _avance(gen g, context arg1) {
    return new gen(giacJNI._avance(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _recule(gen g, context arg1) {
    return new gen(giacJNI._recule(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _position(gen g, context arg1) {
    return new gen(giacJNI._position(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cap(gen g, context arg1) {
    return new gen(giacJNI._cap(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tourne_droite(gen g, context arg1) {
    return new gen(giacJNI._tourne_droite(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tourne_gauche(gen g, context arg1) {
    return new gen(giacJNI._tourne_gauche(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _leve_crayon(gen g, context arg1) {
    return new gen(giacJNI._leve_crayon(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _baisse_crayon(gen g, context arg1) {
    return new gen(giacJNI._baisse_crayon(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ecris(gen g, context arg1) {
    return new gen(giacJNI._ecris(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _signe(gen g, context arg1) {
    return new gen(giacJNI._signe(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _saute(gen g, context arg1) {
    return new gen(giacJNI._saute(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pas_de_cote(gen g, context arg1) {
    return new gen(giacJNI._pas_de_cote(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cache_tortue(gen g, context arg1) {
    return new gen(giacJNI._cache_tortue(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _montre_tortue(gen g, context arg1) {
    return new gen(giacJNI._montre_tortue(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _debut_enregistrement(gen g0, context arg1) {
    return new gen(giacJNI._debut_enregistrement(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fin_enregistrement(gen g0, context arg1) {
    return new gen(giacJNI._fin_enregistrement(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _repete(gen g, context arg1) {
    return new gen(giacJNI._repete(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _crayon(gen g, context arg1) {
    return new gen(giacJNI._crayon(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _efface(gen g, context arg1) {
    return new gen(giacJNI._efface(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _vers(gen g, context arg1) {
    return new gen(giacJNI._vers(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rond(gen g, context arg1) {
    return new gen(giacJNI._rond(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _disque(gen g, context arg1) {
    return new gen(giacJNI._disque(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _disque_centre(gen g, context arg1) {
    return new gen(giacJNI._disque_centre(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polygone_rempli(gen g, context arg1) {
    return new gen(giacJNI._polygone_rempli(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rectangle_plein(gen g, context arg1) {
    return new gen(giacJNI._rectangle_plein(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _triangle_plein(gen g, context arg1) {
    return new gen(giacJNI._triangle_plein(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dessine_tortue(gen g, context arg1) {
    return new gen(giacJNI._dessine_tortue(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _arc(gen args, context arg1) {
    return new gen(giacJNI._arc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur plotpreprocess(gen args, context arg1) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.plotpreprocess(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static boolean chk_double_interval(gen g, SWIGTYPE_p_double inf, SWIGTYPE_p_double sup, context arg3) {
    return giacJNI.chk_double_interval(gen.getCPtr(g), g, SWIGTYPE_p_double.getCPtr(inf), SWIGTYPE_p_double.getCPtr(sup), context.getCPtr(arg3), arg3);
  }

  public static void ck_parameter(gen arg0, context arg1) {
    giacJNI.ck_parameter(gen.getCPtr(arg0), arg0, context.getCPtr(arg1), arg1);
  }

  public static gen _erase3d(gen args, context arg1) {
    return new gen(giacJNI._erase3d(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static void rewrite_with_t_real(gen eq, gen t, context arg2) {
    giacJNI.rewrite_with_t_real(gen.getCPtr(eq), eq, gen.getCPtr(t), t, context.getCPtr(arg2), arg2);
  }

  public static boolean on(gen e_orig, gen f, gen t, context arg3) {
    return giacJNI.on(gen.getCPtr(e_orig), e_orig, gen.getCPtr(f), f, gen.getCPtr(t), t, context.getCPtr(arg3), arg3);
  }

  public static gen plotcontour(gen f0, boolean contour, context arg2) {
    return new gen(giacJNI.plotcontour(gen.getCPtr(f0), f0, contour, context.getCPtr(arg2), arg2), true);
  }

  public static gen _aire(gen args, context arg1) {
    return new gen(giacJNI._aire(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _perimetre(gen args, context arg1) {
    return new gen(giacJNI._perimetre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotfunc(gen arg0, context arg1) {
    return new gen(giacJNI._plotfunc(gen.getCPtr(arg0), arg0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _erase(gen args, context arg1) {
    return new gen(giacJNI._erase(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pixon(gen args, context arg1) {
    return new gen(giacJNI._pixon(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pixoff(gen args, context arg1) {
    return new gen(giacJNI._pixoff(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _droite(gen args, context arg1) {
    return new gen(giacJNI._droite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _slope(gen args, context arg1) {
    return new gen(giacJNI._slope(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _demi_droite(gen args, context arg1) {
    return new gen(giacJNI._demi_droite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _segment(gen args, context arg1) {
    return new gen(giacJNI._segment(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen symb_segment(gen x, gen y, SWIGTYPE_p_giac__vecteur arg2, int arg3, context arg4) {
    return new gen(giacJNI.symb_segment(gen.getCPtr(x), x, gen.getCPtr(y), y, SWIGTYPE_p_giac__vecteur.getCPtr(arg2), arg3, context.getCPtr(arg4), arg4), true);
  }

  public static gen symb_pnt_name(gen x, gen c, gen nom, context arg3) {
    return new gen(giacJNI.symb_pnt_name(gen.getCPtr(x), x, gen.getCPtr(c), c, gen.getCPtr(nom), nom, context.getCPtr(arg3), arg3), true);
  }

  public static gen symb_pnt(gen x, gen c, context arg2) {
    return new gen(giacJNI.symb_pnt__SWIG_0(gen.getCPtr(x), x, gen.getCPtr(c), c, context.getCPtr(arg2), arg2), true);
  }

  public static gen pnt_attrib(gen point, SWIGTYPE_p_giac__vecteur attributs, context arg2) {
    return new gen(giacJNI.pnt_attrib(gen.getCPtr(point), point, SWIGTYPE_p_giac__vecteur.getCPtr(attributs), context.getCPtr(arg2), arg2), true);
  }

  public static gen symb_pnt(gen x, context arg1) {
    return new gen(giacJNI.symb_pnt__SWIG_1(gen.getCPtr(x), x, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pnt(gen args, context arg1) {
    return new gen(giacJNI._pnt(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _animation(gen args, context arg1) {
    return new gen(giacJNI._animation(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _point(gen args, context arg1) {
    return new gen(giacJNI._point(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _affixe(gen args, context arg1) {
    return new gen(giacJNI._affixe(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _abscisse(gen args, context arg1) {
    return new gen(giacJNI._abscisse(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ordonnee(gen args, context arg1) {
    return new gen(giacJNI._ordonnee(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cote(gen args, context arg1) {
    return new gen(giacJNI._cote(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _coordonnees(gen args, context arg1) {
    return new gen(giacJNI._coordonnees(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _coordonnees_polaires(gen args, context arg1) {
    return new gen(giacJNI._coordonnees_polaires(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _coordonnees_rectangulaires(gen args, context arg1) {
    return new gen(giacJNI._coordonnees_rectangulaires(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _point_polaire(gen args, context arg1) {
    return new gen(giacJNI._point_polaire(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cercle(gen args, context arg1) {
    return new gen(giacJNI._cercle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static boolean centre_rayon(gen cercle, gen centre, gen rayon, boolean absrayon, context arg4) {
    return giacJNI.centre_rayon(gen.getCPtr(cercle), cercle, gen.getCPtr(centre), centre, gen.getCPtr(rayon), rayon, absrayon, context.getCPtr(arg4), arg4);
  }

  public static gen _centre(gen args, context arg1) {
    return new gen(giacJNI._centre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rayon(gen args, context arg1) {
    return new gen(giacJNI._rayon(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _milieu(gen args, context arg1) {
    return new gen(giacJNI._milieu(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mediatrice(gen args, context arg1) {
    return new gen(giacJNI._mediatrice(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen bissectrice(gen args, boolean interieur, context arg2) {
    return new gen(giacJNI.bissectrice(gen.getCPtr(args), args, interieur, context.getCPtr(arg2), arg2), true);
  }

  public static gen _bissectrice(gen args, context arg1) {
    return new gen(giacJNI._bissectrice(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _exbissectrice(gen args, context arg1) {
    return new gen(giacJNI._exbissectrice(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mediane(gen args, context arg1) {
    return new gen(giacJNI._mediane(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _circonscrit(gen args, context arg1) {
    return new gen(giacJNI._circonscrit(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _orthocentre(gen arg_orig, context arg1) {
    return new gen(giacJNI._orthocentre(gen.getCPtr(arg_orig), arg_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inscrit(gen args, context arg1) {
    return new gen(giacJNI._inscrit(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _exinscrit(gen args, context arg1) {
    return new gen(giacJNI._exinscrit(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _isobarycentre(gen args, context arg1) {
    return new gen(giacJNI._isobarycentre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _barycentre(gen args, context arg1) {
    return new gen(giacJNI._barycentre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen perpendiculaire(gen args, boolean suppl, context arg2) {
    return new gen(giacJNI.perpendiculaire(gen.getCPtr(args), args, suppl, context.getCPtr(arg2), arg2), true);
  }

  public static gen _perpendiculaire(gen args, context arg1) {
    return new gen(giacJNI._perpendiculaire(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _orthogonal(gen args, context arg1) {
    return new gen(giacJNI._orthogonal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _parallele(gen args, context arg1) {
    return new gen(giacJNI._parallele(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen distance2pp(gen ee, gen ff, context arg2) {
    return new gen(giacJNI.distance2pp(gen.getCPtr(ee), ee, gen.getCPtr(ff), ff, context.getCPtr(arg2), arg2), true);
  }

  public static gen distance2(gen f1, gen f2, context arg2) {
    return new gen(giacJNI.distance2(gen.getCPtr(f1), f1, gen.getCPtr(f2), f2, context.getCPtr(arg2), arg2), true);
  }

  public static gen _longueur2(gen args, context arg1) {
    return new gen(giacJNI._longueur2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _longueur(gen args, context arg1) {
    return new gen(giacJNI._longueur(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _angle(gen args, context arg1) {
    return new gen(giacJNI._angle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen scalar_product(gen a, gen b, context arg2) {
    return new gen(giacJNI.scalar_product(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen projection(gen a, gen b, gen c, context arg3) {
    return new gen(giacJNI.projection__SWIG_0(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg3), arg3), true);
  }

  public static gen projection(gen e, gen p, context arg2) {
    return new gen(giacJNI.projection__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(p), p, context.getCPtr(arg2), arg2), true);
  }

  public static gen parameter2point(SWIGTYPE_p_giac__vecteur v, context arg1) {
    return new gen(giacJNI.parameter2point(SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg1), arg1), true);
  }

  public static gen cercle2curve(gen f, context arg1) {
    return new gen(giacJNI.cercle2curve(gen.getCPtr(f), f, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur inter(gen a, gen b, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.inter(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen _click(gen args, context arg1) {
    return new gen(giacJNI._click(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _element(gen args, context arg1) {
    return new gen(giacJNI._element(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _as_function_of(gen args, context arg1) {
    return new gen(giacJNI._as_function_of(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lieu(gen args, context arg1) {
    return new gen(giacJNI._lieu(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _head(gen args, context arg1) {
    return new gen(giacJNI._head(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tail(gen args, context arg1) {
    return new gen(giacJNI._tail(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sommets(gen args, context arg1) {
    return new gen(giacJNI._sommets(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sommets_abca(gen args, context arg1) {
    return new gen(giacJNI._sommets_abca(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _symetrie(gen args, context arg1) {
    return new gen(giacJNI._symetrie(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rotation(gen args, context arg1) {
    return new gen(giacJNI._rotation(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _projection(gen args, context arg1) {
    return new gen(giacJNI._projection(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _homothetie(gen args, context arg1) {
    return new gen(giacJNI._homothetie(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_coplanaire(gen args, context arg1) {
    return new gen(giacJNI._est_coplanaire(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_aligne(gen args, context arg1) {
    return new gen(giacJNI._est_aligne(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_cocyclique(gen args, context arg1) {
    return new gen(giacJNI._est_cocyclique(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_parallele(gen args, context arg1) {
    return new gen(giacJNI._est_parallele(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_perpendiculaire(gen args, context arg1) {
    return new gen(giacJNI._est_perpendiculaire(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_element(gen args, context arg1) {
    return new gen(giacJNI._est_element(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inversion(gen args, context arg1) {
    return new gen(giacJNI._inversion(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _similitude(gen args, context arg1) {
    return new gen(giacJNI._similitude(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen translation(gen a, gen bb, context arg2) {
    return new gen(giacJNI.translation(gen.getCPtr(a), a, gen.getCPtr(bb), bb, context.getCPtr(arg2), arg2), true);
  }

  public static gen _translation(gen args, context arg1) {
    return new gen(giacJNI._translation(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _curve(gen args, context arg1) {
    return new gen(giacJNI._curve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotparam(gen args, context arg1) {
    return new gen(giacJNI._plotparam(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotpolar(gen args, context arg1) {
    return new gen(giacJNI._plotpolar(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _parameq(gen args, context arg1) {
    return new gen(giacJNI._parameq(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _equation(gen args, context arg1) {
    return new gen(giacJNI._equation(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen equation_homogene(gen eq, context arg1) {
    return new gen(giacJNI.equation_homogene(gen.getCPtr(eq), eq, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tangent(gen args, context arg1) {
    return new gen(giacJNI._tangent(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ellipse(gen args, context arg1) {
    return new gen(giacJNI._ellipse(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hyperbole(gen args, context arg1) {
    return new gen(giacJNI._hyperbole(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _parabole(gen args, context arg1) {
    return new gen(giacJNI._parabole(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _conique(gen args, context arg1) {
    return new gen(giacJNI._conique(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _legende(gen args, context arg1) {
    return new gen(giacJNI._legende(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _distanceat(gen args, context arg1) {
    return new gen(giacJNI._distanceat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _distanceatraw(gen args, context arg1) {
    return new gen(giacJNI._distanceatraw(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _areaatraw(gen args, context arg1) {
    return new gen(giacJNI._areaatraw(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _areaat(gen args, context arg1) {
    return new gen(giacJNI._areaat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _slopeatraw(gen args, context arg1) {
    return new gen(giacJNI._slopeatraw(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _slopeat(gen args, context arg1) {
    return new gen(giacJNI._slopeat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _perimeterat(gen args, context arg1) {
    return new gen(giacJNI._perimeterat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _perimeteratraw(gen args, context arg1) {
    return new gen(giacJNI._perimeteratraw(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _extract_measure(gen valeur, context arg1) {
    return new gen(giacJNI._extract_measure(gen.getCPtr(valeur), valeur, context.getCPtr(arg1), arg1), true);
  }

  public static gen _angleat(gen args, context arg1) {
    return new gen(giacJNI._angleat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _angleatraw(gen args, context arg1) {
    return new gen(giacJNI._angleatraw(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _couleur(gen args, context arg1) {
    return new gen(giacJNI._couleur(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _parameter(gen args, context arg1) {
    return new gen(giacJNI._parameter(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hauteur(gen args, context arg1) {
    return new gen(giacJNI._hauteur(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _triangle(gen args, context arg1) {
    return new gen(giacJNI._triangle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _triangle_rectangle(gen args, context arg1) {
    return new gen(giacJNI._triangle_rectangle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _triangle_isocele(gen args, context arg1) {
    return new gen(giacJNI._triangle_isocele(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _triangle_equilateral(gen args, context arg1) {
    return new gen(giacJNI._triangle_equilateral(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _parallelogramme(gen args, context arg1) {
    return new gen(giacJNI._parallelogramme(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _isopolygone(gen args, context arg1) {
    return new gen(giacJNI._isopolygone(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _carre(gen args, context arg1) {
    return new gen(giacJNI._carre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hexagone(gen args, context arg1) {
    return new gen(giacJNI._hexagone(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quadrilatere(gen args, context arg1) {
    return new gen(giacJNI._quadrilatere(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rectangle(gen args, context arg1) {
    return new gen(giacJNI._rectangle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _losange(gen args, context arg1) {
    return new gen(giacJNI._losange(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polygone(gen args, context arg1) {
    return new gen(giacJNI._polygone(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polygone_ouvert(gen args, context arg1) {
    return new gen(giacJNI._polygone_ouvert(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotfield(gen args, context arg1) {
    return new gen(giacJNI._plotfield(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _interactive_plotode(gen args, context arg1) {
    return new gen(giacJNI._interactive_plotode(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotode(gen args, context arg1) {
    return new gen(giacJNI._plotode(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen archive_session(boolean save_history, String s, context arg2) {
    return new gen(giacJNI.archive_session(save_history, s, context.getCPtr(arg2), arg2), true);
  }

  public static gen unarchive_session_string(String s, int level, gen replace, context arg3) {
    return new gen(giacJNI.unarchive_session_string(s, level, gen.getCPtr(replace), replace, context.getCPtr(arg3), arg3), true);
  }

  public static gen _unarchive(gen args, context arg1) {
    return new gen(giacJNI._unarchive(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _xyztrange(gen args, context arg1) {
    return new gen(giacJNI._xyztrange(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _switch_axes(gen args, context arg1) {
    return new gen(giacJNI._switch_axes(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotseq(gen args, context arg1) {
    return new gen(giacJNI._plotseq(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotimplicit(gen args, context arg1) {
    return new gen(giacJNI._plotimplicit(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotcontour(gen args, context arg1) {
    return new gen(giacJNI._plotcontour(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plotinequation(gen f0, context arg1) {
    return new gen(giacJNI._plotinequation(gen.getCPtr(f0), f0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inter_droite(gen args, context arg1) {
    return new gen(giacJNI._inter_droite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dot_paper(gen args, context arg1) {
    return new gen(giacJNI._dot_paper(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _grid_paper(gen args, context arg1) {
    return new gen(giacJNI._grid_paper(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _triangle_paper(gen args, context arg1) {
    return new gen(giacJNI._triangle_paper(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _line_paper(gen args, context arg1) {
    return new gen(giacJNI._line_paper(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _bitmap(gen args, context arg1) {
    return new gen(giacJNI._bitmap(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Pictsize(gen args, context arg1) {
    return new gen(giacJNI._Pictsize(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plot_style(gen args, context arg1) {
    return new gen(giacJNI._plot_style(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DrawInv(gen args, context arg1) {
    return new gen(giacJNI._DrawInv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Graph(gen g, context arg1) {
    return new gen(giacJNI._Graph(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DrwCtour(gen g, context arg1) {
    return new gen(giacJNI._DrwCtour(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static int est_isocele(gen a, gen b, gen c, context arg3) {
    return giacJNI.est_isocele(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg3), arg3);
  }

  public static gen _est_isocele(gen args, context arg1) {
    return new gen(giacJNI._est_isocele(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static boolean est_equilateral(gen a, gen b, gen c, context arg3) {
    return giacJNI.est_equilateral(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg3), arg3);
  }

  public static gen _est_equilateral(gen args, context arg1) {
    return new gen(giacJNI._est_equilateral(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static boolean est_carre(gen a, gen b, gen c, gen d, context arg4) {
    return giacJNI.est_carre(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, context.getCPtr(arg4), arg4);
  }

  public static gen _est_carre(gen args, context arg1) {
    return new gen(giacJNI._est_carre(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static int est_losange(gen a, gen b, gen c, gen d, context arg4) {
    return giacJNI.est_losange(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, context.getCPtr(arg4), arg4);
  }

  public static gen _est_losange(gen args, context arg1) {
    return new gen(giacJNI._est_losange(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static int est_parallelogramme(gen a, gen b, gen c, gen d, context arg4) {
    return giacJNI.est_parallelogramme(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, context.getCPtr(arg4), arg4);
  }

  public static gen _est_parallelogramme(gen args, context arg1) {
    return new gen(giacJNI._est_parallelogramme(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static int est_rect(gen a, gen b, gen c, gen d, context arg4) {
    return giacJNI.est_rect(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, context.getCPtr(arg4), arg4);
  }

  public static gen _est_rectangle(gen args, context arg1) {
    return new gen(giacJNI._est_rectangle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_harmonique(gen args, context arg1) {
    return new gen(giacJNI._est_harmonique(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _div_harmonique(gen args, context arg1) {
    return new gen(giacJNI._div_harmonique(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _point_div(gen args, context arg1) {
    return new gen(giacJNI._point_div(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _birapport(gen args, context arg1) {
    return new gen(giacJNI._birapport(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _conj_harmonique(gen args, context arg1) {
    return new gen(giacJNI._conj_harmonique(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _puissance(gen args, context arg1) {
    return new gen(giacJNI._puissance(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _axe_radical(gen args, context arg1) {
    return new gen(giacJNI._axe_radical(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polaire(gen args, context arg1) {
    return new gen(giacJNI._polaire(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pole(gen args, context arg1) {
    return new gen(giacJNI._pole(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polaire_reciproque(gen args, context arg1) {
    return new gen(giacJNI._polaire_reciproque(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_orthogonal(gen args, context arg1) {
    return new gen(giacJNI._est_orthogonal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_conjugue(gen args, context arg1) {
    return new gen(giacJNI._est_conjugue(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_faisceau_cercle(gen args, context arg1) {
    return new gen(giacJNI._est_faisceau_cercle(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _est_faisceau_droite(gen args, context arg1) {
    return new gen(giacJNI._est_faisceau_droite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static int est_faisceau_droite(gen a, gen b, gen c, context arg3) {
    return giacJNI.est_faisceau_droite(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg3), arg3);
  }

  public static gen _enveloppe(gen args, context arg1) {
    return new gen(giacJNI._enveloppe(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen put_attributs(gen lieu_geo, SWIGTYPE_p_giac__vecteur attributs, context arg2) {
    return new gen(giacJNI.put_attributs(gen.getCPtr(lieu_geo), lieu_geo, SWIGTYPE_p_giac__vecteur.getCPtr(attributs), context.getCPtr(arg2), arg2), true);
  }

  public static int est_aligne(gen a, gen b, gen c, context arg3) {
    return giacJNI.est_aligne(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg3), arg3);
  }

  public static boolean est_coplanaire(gen a, gen b, gen c, gen d, context arg4) {
    return giacJNI.est_coplanaire(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, context.getCPtr(arg4), arg4);
  }

  public static boolean est_cocyclique(gen a, gen b, gen c, gen d, context arg4) {
    return giacJNI.est_cocyclique(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, context.getCPtr(arg4), arg4);
  }

  public static boolean est_parallele(gen a, gen b, context arg2) {
    return giacJNI.est_parallele(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2);
  }

  public static boolean est_perpendiculaire(gen a, gen b, context arg2) {
    return giacJNI.est_perpendiculaire(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2);
  }

  public static int est_element(gen a_orig, gen b_orig, context arg2) {
    return giacJNI.est_element(gen.getCPtr(a_orig), a_orig, gen.getCPtr(b_orig), b_orig, context.getCPtr(arg2), arg2);
  }

  public static int est_trianglerect(gen a, gen b, gen c, context arg3) {
    return giacJNI.est_trianglerect(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, context.getCPtr(arg3), arg3);
  }

  public static boolean est_orthogonal(gen c1, gen R1, gen c2, gen R2, context arg4) {
    return giacJNI.est_orthogonal(gen.getCPtr(c1), c1, gen.getCPtr(R1), R1, gen.getCPtr(c2), c2, gen.getCPtr(R2), R2, context.getCPtr(arg4), arg4);
  }

  public static boolean est_harmonique(gen a, gen b, gen c, gen d, context arg4) {
    return giacJNI.est_harmonique(gen.getCPtr(a), a, gen.getCPtr(b), b, gen.getCPtr(c), c, gen.getCPtr(d), d, context.getCPtr(arg4), arg4);
  }

  public static gen _vector(gen args, context arg1) {
    return new gen(giacJNI._vector(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Ox_2d_unit_vector(gen args, context arg1) {
    return new gen(giacJNI._Ox_2d_unit_vector(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Oy_2d_unit_vector(gen args, context arg1) {
    return new gen(giacJNI._Oy_2d_unit_vector(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _frame_2d(gen args, context arg1) {
    return new gen(giacJNI._frame_2d(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Ox_3d_unit_vector(gen args, context arg1) {
    return new gen(giacJNI._Ox_3d_unit_vector(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Oy_3d_unit_vector(gen args, context arg1) {
    return new gen(giacJNI._Oy_3d_unit_vector(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Oz_3d_unit_vector(gen args, context arg1) {
    return new gen(giacJNI._Oz_3d_unit_vector(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _frame_3d(gen args, context arg1) {
    return new gen(giacJNI._frame_3d(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static void increment_instruction(gen arg, context arg1) {
    giacJNI.increment_instruction(gen.getCPtr(arg), arg, context.getCPtr(arg1), arg1);
  }

  public static String check_local_assign(gen g, context arg1) {
    return giacJNI.check_local_assign(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static gen quote_program(gen args, context arg1) {
    return new gen(giacJNI.quote_program(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _program(gen args, gen name, context arg2) {
    return new gen(giacJNI._program(gen.getCPtr(args), args, gen.getCPtr(name), name, context.getCPtr(arg2), arg2), true);
  }

  public static void adjust_sst_at(gen name, context arg1) {
    giacJNI.adjust_sst_at(gen.getCPtr(name), name, context.getCPtr(arg1), arg1);
  }

  public static gen _bloc(gen prog, context arg1) {
    return new gen(giacJNI._bloc(gen.getCPtr(prog), prog, context.getCPtr(arg1), arg1), true);
  }

  public static String printasfor(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printasfor(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static String printasifte(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printasifte(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static gen _ifte(gen e, context arg1) {
    return new gen(giacJNI._ifte(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _evalb(gen e, context arg1) {
    return new gen(giacJNI._evalb(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _when(gen e, context arg1) {
    return new gen(giacJNI._when(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _for(gen e, context arg1) {
    return new gen(giacJNI._for(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _local(gen args, context arg1) {
    return new gen(giacJNI._local(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _try_catch(gen args, context arg1) {
    return new gen(giacJNI._try_catch(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _check_type(gen args, context arg1) {
    return new gen(giacJNI._check_type(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _type(gen args, context arg1) {
    return new gen(giacJNI._type(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _nop(gen a, context arg1) {
    return new gen(giacJNI._nop(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _feuille(gen args, context arg1) {
    return new gen(giacJNI._feuille(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _maple_op(gen args, context arg1) {
    return new gen(giacJNI._maple_op(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sommet(gen args, context arg1) {
    return new gen(giacJNI._sommet(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen subsop(gen g, SWIGTYPE_p_giac__vecteur v, context arg2) {
    return new gen(giacJNI.subsop__SWIG_0(gen.getCPtr(g), g, SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg2), arg2), true);
  }

  public static gen subsop(SWIGTYPE_p_giac__vecteur g, SWIGTYPE_p_giac__vecteur v, gen sommet, context arg3) {
    return new gen(giacJNI.subsop__SWIG_1(SWIGTYPE_p_giac__vecteur.getCPtr(g), SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(sommet), sommet, context.getCPtr(arg3), arg3), true);
  }

  public static gen _maple_subsop(gen args, context arg1) {
    return new gen(giacJNI._maple_subsop(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _subsop(gen args, context arg1) {
    return new gen(giacJNI._subsop(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _append(gen args, context arg1) {
    return new gen(giacJNI._append(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _prepend(gen args, context arg1) {
    return new gen(giacJNI._prepend(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen concat(gen g, boolean glue_lines, context arg2) {
    return new gen(giacJNI.concat(gen.getCPtr(g), g, glue_lines, context.getCPtr(arg2), arg2), true);
  }

  public static gen _concat(gen args, context arg1) {
    return new gen(giacJNI._concat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _contains(gen args, context arg1) {
    return new gen(giacJNI._contains(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _select(gen args, context arg1) {
    return new gen(giacJNI._select(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _remove(gen args, context arg1) {
    return new gen(giacJNI._remove(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _option(gen args, context arg1) {
    return new gen(giacJNI._option(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _case(gen args, context arg1) {
    return new gen(giacJNI._case(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rand(gen args, context arg1) {
    return new gen(giacJNI._rand(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen rand_interval(SWIGTYPE_p_giac__vecteur v, boolean entier, context arg2) {
    return new gen(giacJNI.rand_interval(SWIGTYPE_p_giac__vecteur.getCPtr(v), entier, context.getCPtr(arg2), arg2), true);
  }

  public static gen _srand(gen args, context arg1) {
    return new gen(giacJNI._srand(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _char(gen args, context arg1) {
    return new gen(giacJNI._char(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _asc(gen args, context arg1) {
    return new gen(giacJNI._asc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _map(gen args, context arg1) {
    return new gen(giacJNI._map(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _apply(gen args, context arg1) {
    return new gen(giacJNI._apply(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _makelist(gen args, context arg1) {
    return new gen(giacJNI._makelist(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _interval(gen args, context arg1) {
    return new gen(giacJNI._interval(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _comment(gen args, context arg1) {
    return new gen(giacJNI._comment(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _throw(gen args, context arg1) {
    return new gen(giacJNI._throw(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _union(gen args, context arg1) {
    return new gen(giacJNI._union(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _intersect(gen args, context arg1) {
    return new gen(giacJNI._intersect(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inter(gen args, context arg1) {
    return new gen(giacJNI._inter(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _minus(gen args, context arg1) {
    return new gen(giacJNI._minus(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dollar(gen args, context arg1) {
    return new gen(giacJNI._dollar(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _makemat(gen args, context arg1) {
    return new gen(giacJNI._makemat(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _compose(gen args, context arg1) {
    return new gen(giacJNI._compose(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _composepow(gen args, context arg1) {
    return new gen(giacJNI._composepow(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _has(gen args, context arg1) {
    return new gen(giacJNI._has(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _args(gen args, context arg1) {
    return new gen(giacJNI._args(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lname(gen args, context arg1) {
    return new gen(giacJNI._lname(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _halt(gen args, context arg1) {
    return new gen(giacJNI._halt(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _kill(gen args, context arg1) {
    return new gen(giacJNI._kill(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cont(gen args, context arg1) {
    return new gen(giacJNI._cont(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sst(gen args, context arg1) {
    return new gen(giacJNI._sst(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sst_in(gen args, context arg1) {
    return new gen(giacJNI._sst_in(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _debug(gen args, context arg1) {
    return new gen(giacJNI._debug(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _watch(gen args, context arg1) {
    return new gen(giacJNI._watch(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rmwatch(gen args, context arg1) {
    return new gen(giacJNI._rmwatch(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _breakpoint(gen args, context arg1) {
    return new gen(giacJNI._breakpoint(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rmbreakpoint(gen args, context arg1) {
    return new gen(giacJNI._rmbreakpoint(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static void debug_loop(gen res, context arg1) {
    giacJNI.debug_loop(gen.getCPtr(res), res, context.getCPtr(arg1), arg1);
  }

  public static gen _backquote(gen args, context arg1) {
    return new gen(giacJNI._backquote(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _double_deux_points(gen args, context arg1) {
    return new gen(giacJNI._double_deux_points(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _maple2mupad(gen args, context arg1) {
    return new gen(giacJNI._maple2mupad(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _maple2xcas(gen args, context arg1) {
    return new gen(giacJNI._maple2xcas(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mupad2maple(gen args, context arg1) {
    return new gen(giacJNI._mupad2maple(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mupad2xcas(gen args, context arg1) {
    return new gen(giacJNI._mupad2xcas(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cd(gen args, context arg1) {
    return new gen(giacJNI._cd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pwd(gen args, context arg1) {
    return new gen(giacJNI._pwd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _scientific_format(gen args, context arg1) {
    return new gen(giacJNI._scientific_format(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _integer_format(gen g, context arg1) {
    return new gen(giacJNI._integer_format(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen giac_eval_level(gen g, context arg1) {
    return new gen(giacJNI.giac_eval_level(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _prog_eval_level(gen g, context arg1) {
    return new gen(giacJNI._prog_eval_level(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _with_sqrt(gen g, context arg1) {
    return new gen(giacJNI._with_sqrt(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _xcas_mode(gen args, context arg1) {
    return new gen(giacJNI._xcas_mode(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _all_trig_solutions(gen args, context arg1) {
    return new gen(giacJNI._all_trig_solutions(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ntl_on(gen args, context arg1) {
    return new gen(giacJNI._ntl_on(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _complex_mode(gen args, context arg1) {
    return new gen(giacJNI._complex_mode(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _angle_radian(gen args, context arg1) {
    return new gen(giacJNI._angle_radian(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _epsilon(gen args, context arg1) {
    return new gen(giacJNI._epsilon(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _proba_epsilon(gen args, context arg1) {
    return new gen(giacJNI._proba_epsilon(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _complex_variables(gen args, context arg1) {
    return new gen(giacJNI._complex_variables(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _approx_mode(gen args, context arg1) {
    return new gen(giacJNI._approx_mode(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _threads(gen args, context arg1) {
    return new gen(giacJNI._threads(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _threads_allowed(gen g, context arg1) {
    return new gen(giacJNI._threads_allowed(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mpzclass_allowed(gen g, context arg1) {
    return new gen(giacJNI._mpzclass_allowed(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cas_setup(gen args, context arg1) {
    return new gen(giacJNI._cas_setup(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Digits(gen args, context arg1) {
    return new gen(giacJNI._Digits(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _insmod(gen args, context arg1) {
    return new gen(giacJNI._insmod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _xport(gen args, context arg1) {
    return new gen(giacJNI._xport(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rmmod(gen args, context arg1) {
    return new gen(giacJNI._rmmod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lsmod(gen args, context arg1) {
    return new gen(giacJNI._lsmod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _virgule(gen args, context arg1) {
    return new gen(giacJNI._virgule(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sort(gen args, context arg1) {
    return new gen(giacJNI._sort(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ans(gen args, context arg1) {
    return new gen(giacJNI._ans(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quest(gen args, context arg1) {
    return new gen(giacJNI._quest(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _convert(gen args, context arg1) {
    return new gen(giacJNI._convert(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _deuxpoints(gen args, context arg1) {
    return new gen(giacJNI._deuxpoints(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen quote_read(gen args, context arg1) {
    return new gen(giacJNI.quote_read(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _read(gen args, context arg1) {
    return new gen(giacJNI._read(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _write(gen args, context arg1) {
    return new gen(giacJNI._write(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _save_history(gen args, context arg1) {
    return new gen(giacJNI._save_history(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _findhelp(gen args, context arg1) {
    return new gen(giacJNI._findhelp(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _member(gen args, context arg1) {
    return new gen(giacJNI._member(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tablefunc(gen args, context arg1) {
    return new gen(giacJNI._tablefunc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tableseq(gen args, context arg1) {
    return new gen(giacJNI._tableseq(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen protecteval(gen g, int level, context arg2) {
    return new gen(giacJNI.protecteval(gen.getCPtr(g), g, level, context.getCPtr(arg2), arg2), true);
  }

  public static gen _unapply(gen args, context arg1) {
    return new gen(giacJNI._unapply(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _makevector(gen args, context arg1) {
    return new gen(giacJNI._makevector(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _matrix(gen args, context arg1) {
    return new gen(giacJNI._matrix(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _makesuite(gen args, context arg1) {
    return new gen(giacJNI._makesuite(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _break(gen args, context arg1) {
    return new gen(giacJNI._break(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _continue(gen args, context arg1) {
    return new gen(giacJNI._continue(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _label(gen args, context arg1) {
    return new gen(giacJNI._label(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _goto(gen args, context arg1) {
    return new gen(giacJNI._goto(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tilocal(gen args, context arg1) {
    return new gen(giacJNI._tilocal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen inputform_post_analysis(SWIGTYPE_p_giac__vecteur v, gen res, context arg2) {
    return new gen(giacJNI.inputform_post_analysis(SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(res), res, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur inputform_pre_analysis(gen g, context arg1) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.inputform_pre_analysis(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inputform(gen args, context arg1) {
    return new gen(giacJNI._inputform(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _choosebox(gen args, context arg1) {
    return new gen(giacJNI._choosebox(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _output(gen args, context arg1) {
    return new gen(giacJNI._output(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _input(gen args, boolean textinput, context arg2) {
    return new gen(giacJNI._input__SWIG_1(gen.getCPtr(args), args, textinput, context.getCPtr(arg2), arg2), true);
  }

  public static String printastifunction(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printastifunction(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static gen _Dialog(gen args, context arg1) {
    return new gen(giacJNI._Dialog(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Title(gen args, context arg1) {
    return new gen(giacJNI._Title(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Text(gen args, context arg1) {
    return new gen(giacJNI._Text(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Request(gen args, context arg1) {
    return new gen(giacJNI._Request(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DropDown(gen args, context arg1) {
    return new gen(giacJNI._DropDown(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Popup(gen args, context arg1) {
    return new gen(giacJNI._Popup(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _expr(gen args, context arg1) {
    return new gen(giacJNI._expr(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _string(gen args, context arg1) {
    return new gen(giacJNI._string(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _part(gen args, context arg1) {
    return new gen(giacJNI._part(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Pause(gen args, context arg1) {
    return new gen(giacJNI._Pause(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Row(gen args, context arg1) {
    return new gen(giacJNI._Row(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Col(gen args, context arg1) {
    return new gen(giacJNI._Col(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pointprod(gen args, context arg1) {
    return new gen(giacJNI._pointprod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pointdivision(gen args, context arg1) {
    return new gen(giacJNI._pointdivision(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pointpow(gen args, context arg1) {
    return new gen(giacJNI._pointpow(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pourcent(gen args, context arg1) {
    return new gen(giacJNI._pourcent(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hash(gen args, context arg1) {
    return new gen(giacJNI._hash(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _interactive(gen args, context arg1) {
    return new gen(giacJNI._interactive(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static String printassuffix(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printassuffix(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static gen _ti_semi(gen args, context arg1) {
    return new gen(giacJNI._ti_semi(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen widget_size(gen g, context arg1) {
    return new gen(giacJNI.widget_size(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen keyboard(gen g, context arg1) {
    return new gen(giacJNI.keyboard(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen current_sheet(gen g, context arg1) {
    return new gen(giacJNI.current_sheet(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen window_switch(gen g, context arg1) {
    return new gen(giacJNI.window_switch(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen maple_lib(gen g, context arg1) {
    return new gen(giacJNI.maple_lib(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen maple_root(gen g, context arg1) {
    return new gen(giacJNI.maple_root(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen symb_unit(gen a, gen b, context arg2) {
    return new gen(giacJNI.symb_unit(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static String printasDigits(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printasDigits(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static gen user_operator(gen g, context arg1) {
    return new gen(giacJNI.user_operator(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SetFold(gen g, context arg1) {
    return new gen(giacJNI._SetFold(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen simplifier(gen g, context arg1) {
    return new gen(giacJNI.simplifier(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _simplifier(gen g, context arg1) {
    return new gen(giacJNI._simplifier(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen mksa_reduce(gen g, context arg1) {
    return new gen(giacJNI.mksa_reduce(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen find_or_make_symbol(String s, boolean check38, context arg2) {
    return new gen(giacJNI.find_or_make_symbol(s, check38, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__vecteur mksa_convert(gen g, context arg1) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.mksa_convert(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ufactor(gen g, context arg1) {
    return new gen(giacJNI._ufactor(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _usimplify(gen g, context arg1) {
    return new gen(giacJNI._usimplify(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _piecewise(gen g, context arg1) {
    return new gen(giacJNI._piecewise(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen when2piecewise(gen g, context arg1) {
    return new gen(giacJNI.when2piecewise(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen when2sign(gen g, context arg1) {
    return new gen(giacJNI.when2sign(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen piecewise2when(gen g, context arg1) {
    return new gen(giacJNI.piecewise2when(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _geo2d(gen g, context arg1) {
    return new gen(giacJNI._geo2d(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static String printasinnerbloc(gen feuille, context arg1) {
    return giacJNI.printasinnerbloc(gen.getCPtr(feuille), feuille, context.getCPtr(arg1), arg1);
  }

  public static gen symb_local(gen a, gen b, context arg2) {
    return new gen(giacJNI.symb_local__SWIG_0(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen symb_local(gen args, context arg1) {
    return new gen(giacJNI.symb_local__SWIG_1(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen symb_check_type(gen args, context arg1) {
    return new gen(giacJNI.symb_check_type(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quaternion(gen args, context arg1) {
    return new gen(giacJNI._quaternion(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen risch(gen e_orig, SWIGTYPE_p_giac__identificateur x, gen remains_to_integrate, context arg3) {
    return new gen(giacJNI.risch(gen.getCPtr(e_orig), e_orig, SWIGTYPE_p_giac__identificateur.getCPtr(x), gen.getCPtr(remains_to_integrate), remains_to_integrate, context.getCPtr(arg3), arg3), true);
  }

  public static gen _risch(gen g, context arg1) {
    return new gen(giacJNI._risch(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static String printasconstant(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printasconstant(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static gen _rpn(gen args, context arg1) {
    return new gen(giacJNI._rpn(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _alg(gen args, context arg1) {
    return new gen(giacJNI._alg(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _PERCENT(gen args, context arg1) {
    return new gen(giacJNI._PERCENT(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ROLL(gen args, context arg1) {
    return new gen(giacJNI._ROLL(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ROLLD(gen args, context arg1) {
    return new gen(giacJNI._ROLLD(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SWAP(gen args, context arg1) {
    return new gen(giacJNI._SWAP(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DUP(gen args, context arg1) {
    return new gen(giacJNI._DUP(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _OVER(gen args, context arg1) {
    return new gen(giacJNI._OVER(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _PICK(gen args, context arg1) {
    return new gen(giacJNI._PICK(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DROP(gen args, context arg1) {
    return new gen(giacJNI._DROP(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _NOP(gen args, context arg1) {
    return new gen(giacJNI._NOP(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _IFTE(gen args, context arg1) {
    return new gen(giacJNI._IFTE(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RPN_LOCAL(gen args, context arg1) {
    return new gen(giacJNI._RPN_LOCAL(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RPN_FOR(gen args, context arg1) {
    return new gen(giacJNI._RPN_FOR(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RPN_WHILE(gen args, context arg1) {
    return new gen(giacJNI._RPN_WHILE(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RPN_UNTIL(gen args, context arg1) {
    return new gen(giacJNI._RPN_UNTIL(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RPN_CASE(gen args, context arg1) {
    return new gen(giacJNI._RPN_CASE(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RCL(gen args, context arg1) {
    return new gen(giacJNI._RCL(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _VARS(gen args, context arg1) {
    return new gen(giacJNI._VARS(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _purge(gen args, context arg1) {
    return new gen(giacJNI._purge(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rpn_prog(gen args, context arg1) {
    return new gen(giacJNI._rpn_prog(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur rpn_eval(gen prog, SWIGTYPE_p_giac__vecteur pile, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.rpn_eval(gen.getCPtr(prog), prog, SWIGTYPE_p_giac__vecteur.getCPtr(pile), context.getCPtr(arg2), arg2), true);
  }

  public static gen _division(gen args, context arg1) {
    return new gen(giacJNI._division(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _binary_minus(gen args, context arg1) {
    return new gen(giacJNI._binary_minus(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hp38(gen args, context arg1) {
    return new gen(giacJNI._hp38(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ABS(gen args, context arg1) {
    return new gen(giacJNI._ABS(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _MODULO(gen args, context arg1) {
    return new gen(giacJNI._MODULO(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RANDOM(gen g, context arg1) {
    return new gen(giacJNI._RANDOM(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _MAXREAL(gen g, context arg1) {
    return new gen(giacJNI._MAXREAL(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _MINREAL(gen g, context arg1) {
    return new gen(giacJNI._MINREAL(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _EXPM1(gen g, context arg1) {
    return new gen(giacJNI._EXPM1(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _LNP1(gen g, context arg1) {
    return new gen(giacJNI._LNP1(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ADDROW(gen args, context arg1) {
    return new gen(giacJNI._ADDROW(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ADDCOL(gen args, context arg1) {
    return new gen(giacJNI._ADDCOL(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SCALE(gen g, context arg1) {
    return new gen(giacJNI._SCALE(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SCALEADD(gen g, context arg1) {
    return new gen(giacJNI._SCALEADD(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SWAPCOL(gen args, context arg1) {
    return new gen(giacJNI._SWAPCOL(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SUB(gen args, context arg1) {
    return new gen(giacJNI._SUB(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RANDMAT(gen args, context arg1) {
    return new gen(giacJNI._RANDMAT(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _REDIM(gen args, context arg1) {
    return new gen(giacJNI._REDIM(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _REPLACE(gen args, context arg1) {
    return new gen(giacJNI._REPLACE(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _EIGENVAL(gen args, context arg1) {
    return new gen(giacJNI._EIGENVAL(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _EIGENVV(gen args, context arg1) {
    return new gen(giacJNI._EIGENVV(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SIZE(gen args, context arg1) {
    return new gen(giacJNI._SIZE(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _INT(gen g, context arg1) {
    return new gen(giacJNI._INT(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _HPDIFF(gen args, context arg1) {
    return new gen(giacJNI._HPDIFF(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _HPINT(gen args, context arg1) {
    return new gen(giacJNI._HPINT(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _HPSUM(gen args, context arg1) {
    return new gen(giacJNI._HPSUM(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _TAYLOR(gen args, context arg1) {
    return new gen(giacJNI._TAYLOR(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _POLYFORM(gen args, context arg1) {
    return new gen(giacJNI._POLYFORM(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _IS_LINEAR(gen args, context arg1) {
    return new gen(giacJNI._IS_LINEAR(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SVD(gen args0, context arg1) {
    return new gen(giacJNI._SVD(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SVL(gen args0, context arg1) {
    return new gen(giacJNI._SVL(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SPECRAD(gen args0, context arg1) {
    return new gen(giacJNI._SPECRAD(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SPECNORM(gen args0, context arg1) {
    return new gen(giacJNI._SPECNORM(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _COND(gen args0, context arg1) {
    return new gen(giacJNI._COND(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SCHUR(gen args, context arg1) {
    return new gen(giacJNI._SCHUR(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _LQ(gen args0, context arg1) {
    return new gen(giacJNI._LQ(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _LU(gen args0, context arg1) {
    return new gen(giacJNI._LU(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _QR(gen args0, context arg1) {
    return new gen(giacJNI._QR(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _XPON(gen g, context arg1) {
    return new gen(giacJNI._XPON(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _MANT(gen g, context arg1) {
    return new gen(giacJNI._MANT(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _HMSX(gen g0, context arg1) {
    return new gen(giacJNI._HMSX(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _XHMS(gen g0, context arg1) {
    return new gen(giacJNI._XHMS(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DEGXRAD(gen g, context arg1) {
    return new gen(giacJNI._DEGXRAD(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RADXDEG(gen g, context arg1) {
    return new gen(giacJNI._RADXDEG(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _PERCENTCHANGE(gen g, context arg1) {
    return new gen(giacJNI._PERCENTCHANGE(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _PERCENTTOTAL(gen g, context arg1) {
    return new gen(giacJNI._PERCENTTOTAL(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ITERATE(gen args, context arg1) {
    return new gen(giacJNI._ITERATE(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _MAKEMAT(gen args, context arg1) {
    return new gen(giacJNI._MAKEMAT(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _LSQ(gen args, context arg1) {
    return new gen(giacJNI._LSQ(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _isprime(gen args0, context arg1) {
    return new gen(giacJNI._isprime(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _numer(gen args0, context arg1) {
    return new gen(giacJNI._numer(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _denom(gen args0, context arg1) {
    return new gen(giacJNI._denom(gen.getCPtr(args0), args0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _NTHROOT(gen args, context arg1) {
    return new gen(giacJNI._NTHROOT(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Ans(gen args, context arg1) {
    return new gen(giacJNI._Ans(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _VIEWS(gen args, context arg1) {
    return new gen(giacJNI._VIEWS(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static void qualify(gen g, SWIGTYPE_p_giac__vecteur v, gen prog, context arg3) {
    giacJNI.qualify(gen.getCPtr(g), g, SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(prog), prog, context.getCPtr(arg3), arg3);
  }

  public static int seqapp_prepare(gen expr_un, gen expr, SWIGTYPE_p_giac__vecteur vars, context arg3, int seqno) {
    return giacJNI.seqapp_prepare__SWIG_0(gen.getCPtr(expr_un), expr_un, gen.getCPtr(expr), expr, SWIGTYPE_p_giac__vecteur.getCPtr(vars), context.getCPtr(arg3), arg3, seqno);
  }

  public static int seqapp_prepare(gen expr_un, gen expr, SWIGTYPE_p_giac__vecteur vars, context arg3) {
    return giacJNI.seqapp_prepare__SWIG_1(gen.getCPtr(expr_un), expr_un, gen.getCPtr(expr), expr, SWIGTYPE_p_giac__vecteur.getCPtr(vars), context.getCPtr(arg3), arg3);
  }

  public static void lcmdeno(SWIGTYPE_p_giac__vecteur v, gen e, context arg2) {
    giacJNI.lcmdeno(SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(e), e, context.getCPtr(arg2), arg2);
  }

  public static gen series(gen e, gen vars, gen lim_point, gen ordre, context arg4) {
    return new gen(giacJNI.series(gen.getCPtr(e), e, gen.getCPtr(vars), vars, gen.getCPtr(lim_point), lim_point, gen.getCPtr(ordre), ordre, context.getCPtr(arg4), arg4), true);
  }

  public static gen _series(gen args, context arg1) {
    return new gen(giacJNI._series(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _revert(gen args, context arg1) {
    return new gen(giacJNI._revert(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _bounded_function(gen args, context arg1) {
    return new gen(giacJNI._bounded_function(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen bounded_function(context arg0) {
    return new gen(giacJNI.bounded_function(context.getCPtr(arg0), arg0), true);
  }

  public static gen limit(gen e, SWIGTYPE_p_giac__identificateur x, gen lim_point, int direction, context arg4) {
    return new gen(giacJNI.limit(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), gen.getCPtr(lim_point), lim_point, direction, context.getCPtr(arg4), arg4), true);
  }

  public static gen _limit(gen args, context arg1) {
    return new gen(giacJNI._limit(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _euler_mac_laurin(gen args, context arg1) {
    return new gen(giacJNI._euler_mac_laurin(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static boolean convert_to_euler_mac_laurin(gen g, gen res, context arg2) {
    return giacJNI.convert_to_euler_mac_laurin(gen.getCPtr(g), g, gen.getCPtr(res), res, context.getCPtr(arg2), arg2);
  }

  public static SWIGTYPE_p_giac__vecteur find_singularities(gen e, SWIGTYPE_p_giac__identificateur x, int cplxmode, context arg3) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.find_singularities(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), cplxmode, context.getCPtr(arg3), arg3), true);
  }

  public static SWIGTYPE_p_giac__vecteur solve(gen e, SWIGTYPE_p_giac__identificateur x, int isolate_mode, context arg3) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.solve__SWIG_0(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), isolate_mode, context.getCPtr(arg3), arg3), true);
  }

  public static SWIGTYPE_p_giac__vecteur solve(gen e, gen x, int isolate_mode, context arg3) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.solve__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(x), x, isolate_mode, context.getCPtr(arg3), arg3), true);
  }

  public static void solve(gen e, SWIGTYPE_p_giac__identificateur x, SWIGTYPE_p_giac__vecteur v, int isolate_mode, context arg4) {
    giacJNI.solve__SWIG_2(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), SWIGTYPE_p_giac__vecteur.getCPtr(v), isolate_mode, context.getCPtr(arg4), arg4);
  }

  public static void in_solve(gen e, SWIGTYPE_p_giac__identificateur x, SWIGTYPE_p_giac__vecteur v, int isolate_mode, context arg4) {
    giacJNI.in_solve(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), SWIGTYPE_p_giac__vecteur.getCPtr(v), isolate_mode, context.getCPtr(arg4), arg4);
  }

  public static boolean modpolyroot(SWIGTYPE_p_giac__vecteur a, gen p, SWIGTYPE_p_giac__vecteur v, boolean dogcd, context arg4) {
    return giacJNI.modpolyroot(SWIGTYPE_p_giac__vecteur.getCPtr(a), gen.getCPtr(p), p, SWIGTYPE_p_giac__vecteur.getCPtr(v), dogcd, context.getCPtr(arg4), arg4);
  }

  public static gen solvepostprocess(gen g, gen x, context arg2) {
    return new gen(giacJNI.solvepostprocess(gen.getCPtr(g), g, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _solve(gen args, context arg1) {
    return new gen(giacJNI._solve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen in_fsolve(SWIGTYPE_p_giac__vecteur v, context arg1) {
    return new gen(giacJNI.in_fsolve(SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg1), arg1), true);
  }

  public static gen _fsolve(gen args, context arg1) {
    return new gen(giacJNI._fsolve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _linsolve(gen args, context arg1) {
    return new gen(giacJNI._linsolve(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _newton(gen args, context arg1) {
    return new gen(giacJNI._newton(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _greduce(gen args, context arg1) {
    return new gen(giacJNI._greduce(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _gbasis(gen args, context arg1) {
    return new gen(giacJNI._gbasis(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _in_ideal(gen args, context arg1) {
    return new gen(giacJNI._in_ideal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur solvepreprocess(gen args, boolean complex_mode, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.solvepreprocess(gen.getCPtr(args), args, complex_mode, context.getCPtr(arg2), arg2), true);
  }

  public static gen checkanglemode(context arg0) {
    return new gen(giacJNI.checkanglemode(context.getCPtr(arg0), arg0), true);
  }

  public static gen degtorad(gen g, context arg1) {
    return new gen(giacJNI.degtorad(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen radtodeg(gen g, context arg1) {
    return new gen(giacJNI.radtodeg(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur subst(SWIGTYPE_p_giac__vecteur v, gen i, gen newi, boolean quotesubst, context arg4) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.subst__SWIG_0(SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(i), i, gen.getCPtr(newi), newi, quotesubst, context.getCPtr(arg4), arg4), true);
  }

  public static gen subst(gen e, gen i, gen newi, boolean quotesubst, context arg4) {
    return new gen(giacJNI.subst__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(i), i, gen.getCPtr(newi), newi, quotesubst, context.getCPtr(arg4), arg4), true);
  }

  public static gen subst(gen e, SWIGTYPE_p_giac__vecteur i, SWIGTYPE_p_giac__vecteur ewi, boolean quotesubst, context arg4) {
    return new gen(giacJNI.subst__SWIG_2(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(i), SWIGTYPE_p_giac__vecteur.getCPtr(ewi), quotesubst, context.getCPtr(arg4), arg4), true);
  }

  public static gen quotesubst(gen e, gen i, gen newi, context arg3) {
    return new gen(giacJNI.quotesubst(gen.getCPtr(e), e, gen.getCPtr(i), i, gen.getCPtr(newi), newi, context.getCPtr(arg3), arg3), true);
  }

  public static gen halftan(gen e, context arg1) {
    return new gen(giacJNI.halftan(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _halftan(gen args, context arg1) {
    return new gen(giacJNI._halftan(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen shift_phase(gen e, context arg1) {
    return new gen(giacJNI.shift_phase(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _shift_phase(gen args, context arg1) {
    return new gen(giacJNI._shift_phase(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen hyp2exp(gen e, context arg1) {
    return new gen(giacJNI.hyp2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hyp2exp(gen args, context arg1) {
    return new gen(giacJNI._hyp2exp(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen sincos(gen e, context arg1) {
    return new gen(giacJNI.sincos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sincos(gen args, context arg1) {
    return new gen(giacJNI._sincos(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen trig2exp(gen e, context arg1) {
    return new gen(giacJNI.trig2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _trig2exp(gen args, context arg1) {
    return new gen(giacJNI._trig2exp(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen halftan_hyp2exp(gen e, context arg1) {
    return new gen(giacJNI.halftan_hyp2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _halftan_hyp2exp(gen args, context arg1) {
    return new gen(giacJNI._halftan_hyp2exp(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen rewrite_hyper(gen e, context arg1) {
    return new gen(giacJNI.rewrite_hyper(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen asin2acos(gen e, context arg1) {
    return new gen(giacJNI.asin2acos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _asin2acos(gen args, context arg1) {
    return new gen(giacJNI._asin2acos(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen asin2atan(gen e, context arg1) {
    return new gen(giacJNI.asin2atan(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _asin2atan(gen args, context arg1) {
    return new gen(giacJNI._asin2atan(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen acos2asin(gen e, context arg1) {
    return new gen(giacJNI.acos2asin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _acos2asin(gen args, context arg1) {
    return new gen(giacJNI._acos2asin(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen acos2atan(gen e, context arg1) {
    return new gen(giacJNI.acos2atan(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _acos2atan(gen args, context arg1) {
    return new gen(giacJNI._acos2atan(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen atan2acos(gen e, context arg1) {
    return new gen(giacJNI.atan2acos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _atan2acos(gen args, context arg1) {
    return new gen(giacJNI._atan2acos(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen atan2asin(gen e, context arg1) {
    return new gen(giacJNI.atan2asin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _atan2asin(gen args, context arg1) {
    return new gen(giacJNI._atan2asin(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur as_linear_combination(gen g, SWIGTYPE_p_giac__vecteur wrt, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.as_linear_combination(gen.getCPtr(g), g, SWIGTYPE_p_giac__vecteur.getCPtr(wrt), context.getCPtr(arg2), arg2), true);
  }

  public static gen tsimplify_noexpln(gen e, int s1, int s2, context arg3) {
    return new gen(giacJNI.tsimplify_noexpln(gen.getCPtr(e), e, s1, s2, context.getCPtr(arg3), arg3), true);
  }

  public static gen tsimplify_common(gen e, context arg1) {
    return new gen(giacJNI.tsimplify_common(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tsimplify(gen e, context arg1) {
    return new gen(giacJNI.tsimplify(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tsimplify(gen args, context arg1) {
    return new gen(giacJNI._tsimplify(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen simplify(gen e, context arg1) {
    return new gen(giacJNI.simplify__SWIG_1(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen trigcos(gen e, context arg1) {
    return new gen(giacJNI.trigcos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _trigcos(gen args, context arg1) {
    return new gen(giacJNI._trigcos(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen trigsin(gen e, context arg1) {
    return new gen(giacJNI.trigsin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _trigsin(gen args, context arg1) {
    return new gen(giacJNI._trigsin(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen trigtan(gen e, context arg1) {
    return new gen(giacJNI.trigtan(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _trigtan(gen args, context arg1) {
    return new gen(giacJNI._trigtan(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen tan2sincos(gen e, context arg1) {
    return new gen(giacJNI.tan2sincos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tan2sincos(gen args, context arg1) {
    return new gen(giacJNI._tan2sincos(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen tan2sincos2(gen e, context arg1) {
    return new gen(giacJNI.tan2sincos2(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tan2sincos2(gen args, context arg1) {
    return new gen(giacJNI._tan2sincos2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen tan2cossin2(gen e, context arg1) {
    return new gen(giacJNI.tan2cossin2(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tan2cossin2(gen args, context arg1) {
    return new gen(giacJNI._tan2cossin2(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen tcollect(gen e, context arg1) {
    return new gen(giacJNI.tcollect(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tcollect(gen args, context arg1) {
    return new gen(giacJNI._tcollect(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen lncollect(gen e, context arg1) {
    return new gen(giacJNI.lncollect(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lncollect(gen args, context arg1) {
    return new gen(giacJNI._lncollect(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _powexpand(gen args, context arg1) {
    return new gen(giacJNI._powexpand(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen powexpand(gen e, context arg1) {
    return new gen(giacJNI.powexpand(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen exp2pow(gen e, context arg1) {
    return new gen(giacJNI.exp2pow(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _exp2pow(gen args, context arg1) {
    return new gen(giacJNI._exp2pow(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pow2exp(gen e, context arg1) {
    return new gen(giacJNI._pow2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen pow2expln(gen e, context arg1) {
    return new gen(giacJNI.pow2expln__SWIG_0(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen simplifyfactorial(gen g, context arg1) {
    return new gen(giacJNI.simplifyfactorial(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen pow2expln(gen e, SWIGTYPE_p_giac__identificateur x, context arg2) {
    return new gen(giacJNI.pow2expln__SWIG_1(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), context.getCPtr(arg2), arg2), true);
  }

  public static gen gamma2factorial(gen g, context arg1) {
    return new gen(giacJNI.gamma2factorial(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen gammatofactorial(gen g, context arg1) {
    return new gen(giacJNI.gammatofactorial(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen factorial2gamma(gen g, context arg1) {
    return new gen(giacJNI.factorial2gamma(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen factorialtogamma(gen g, context arg1) {
    return new gen(giacJNI.factorialtogamma(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen factor_xn(gen args, gen x, context arg2) {
    return new gen(giacJNI.factor_xn__SWIG_0(gen.getCPtr(args), args, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen factor_xn(gen args, context arg1) {
    return new gen(giacJNI.factor_xn__SWIG_1(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _factor_xn(gen args, context arg1) {
    return new gen(giacJNI._factor_xn(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen Heavisidetosign(gen args, context arg1) {
    return new gen(giacJNI.Heavisidetosign(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Heavisidetosign(gen args, context arg1) {
    return new gen(giacJNI._Heavisidetosign(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen expln2trig(gen g, context arg1) {
    return new gen(giacJNI.expln2trig(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mult_conjugate(gen g0, context arg1) {
    return new gen(giacJNI._mult_conjugate(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mult_c_conjugate(gen g0, context arg1) {
    return new gen(giacJNI._mult_c_conjugate(gen.getCPtr(g0), g0, context.getCPtr(arg1), arg1), true);
  }

  public static gen sin2tan2(gen e, context arg1) {
    return new gen(giacJNI.sin2tan2(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen cos2tan2(gen e, context arg1) {
    return new gen(giacJNI.cos2tan2(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tan2tan2(gen e, context arg1) {
    return new gen(giacJNI.tan2tan2(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen sinh2exp(gen e, context arg1) {
    return new gen(giacJNI.sinh2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen cosh2exp(gen e, context arg1) {
    return new gen(giacJNI.cosh2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tanh2exp(gen e, context arg1) {
    return new gen(giacJNI.tanh2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen inv_test_exp(gen e, context arg1) {
    return new gen(giacJNI.inv_test_exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen sin2exp(gen e, context arg1) {
    return new gen(giacJNI.sin2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen cos2exp(gen e, context arg1) {
    return new gen(giacJNI.cos2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tan2exp(gen e, context arg1) {
    return new gen(giacJNI.tan2exp(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen exp2sincos(gen e, context arg1) {
    return new gen(giacJNI.exp2sincos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tantosincos(gen e, context arg1) {
    return new gen(giacJNI.tantosincos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tantosincos2(gen e, context arg1) {
    return new gen(giacJNI.tantosincos2(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tantocossin2(gen e, context arg1) {
    return new gen(giacJNI.tantocossin2(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen asintoacos(gen e, context arg1) {
    return new gen(giacJNI.asintoacos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen acostoasin(gen e, context arg1) {
    return new gen(giacJNI.acostoasin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen asintoatan(gen e, context arg1) {
    return new gen(giacJNI.asintoatan(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen atantoasin(gen e, context arg1) {
    return new gen(giacJNI.atantoasin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen acostoatan(gen e, context arg1) {
    return new gen(giacJNI.acostoatan(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen atantoacos(gen e, context arg1) {
    return new gen(giacJNI.atantoacos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen trigcospow(gen g, context arg1) {
    return new gen(giacJNI.trigcospow(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen trigsinpow(gen g, context arg1) {
    return new gen(giacJNI.trigsinpow(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen trigtanpow(gen g, context arg1) {
    return new gen(giacJNI.trigtanpow(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen powtopowexpand(gen g, context arg1) {
    return new gen(giacJNI.powtopowexpand(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen exptopower(gen g, context arg1) {
    return new gen(giacJNI.exptopower(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen asin2ln(gen g_orig, context arg1) {
    return new gen(giacJNI.asin2ln(gen.getCPtr(g_orig), g_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen acos2ln(gen g_orig, context arg1) {
    return new gen(giacJNI.acos2ln(gen.getCPtr(g_orig), g_orig, context.getCPtr(arg1), arg1), true);
  }

  public static gen atan2ln(gen g_orig, context arg1) {
    return new gen(giacJNI.atan2ln(gen.getCPtr(g_orig), g_orig, context.getCPtr(arg1), arg1), true);
  }

  public static boolean guess_program(gen g, context arg1) {
    return giacJNI.guess_program(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static gen normal(gen e, context arg1) {
    return new gen(giacJNI.normal__SWIG_0(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen normal(gen e, boolean distribute_div, context arg2) {
    return new gen(giacJNI.normal__SWIG_1(gen.getCPtr(e), e, distribute_div, context.getCPtr(arg2), arg2), true);
  }

  public static gen normalize_sqrt(gen e, context arg1) {
    return new gen(giacJNI.normalize_sqrt(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen recursive_normal(gen e, context arg1) {
    return new gen(giacJNI.recursive_normal__SWIG_0(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _recursive_normal(gen e, context arg1) {
    return new gen(giacJNI._recursive_normal(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen recursive_normal(gen e, boolean distribute_div, context arg2) {
    return new gen(giacJNI.recursive_normal__SWIG_1(gen.getCPtr(e), e, distribute_div, context.getCPtr(arg2), arg2), true);
  }

  public static gen factor(gen e, boolean withsqrt, context arg2) {
    return new gen(giacJNI.factor__SWIG_0(gen.getCPtr(e), e, withsqrt, context.getCPtr(arg2), arg2), true);
  }

  public static gen ratfactor(gen e, boolean withsqrt, context arg2) {
    return new gen(giacJNI.ratfactor(gen.getCPtr(e), e, withsqrt, context.getCPtr(arg2), arg2), true);
  }

  public static gen factor(gen e, gen f, boolean withsqrt, context arg3) {
    return new gen(giacJNI.factor__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(f), f, withsqrt, context.getCPtr(arg3), arg3), true);
  }

  public static gen _collect(gen args, context arg1) {
    return new gen(giacJNI._collect(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen factorcollect(gen args, boolean with_sqrt, context arg2) {
    return new gen(giacJNI.factorcollect(gen.getCPtr(args), args, with_sqrt, context.getCPtr(arg2), arg2), true);
  }

  public static gen partfrac(gen e, SWIGTYPE_p_giac__vecteur l, boolean withsqrt, context arg3) {
    return new gen(giacJNI.partfrac__SWIG_0(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(l), withsqrt, context.getCPtr(arg3), arg3), true);
  }

  public static gen partfrac(gen e, boolean withsqrt, context arg2) {
    return new gen(giacJNI.partfrac__SWIG_1(gen.getCPtr(e), e, withsqrt, context.getCPtr(arg2), arg2), true);
  }

  public static gen partfrac(gen e, SWIGTYPE_p_giac__identificateur x, boolean withsqrt, context arg3) {
    return new gen(giacJNI.partfrac__SWIG_2(gen.getCPtr(e), e, SWIGTYPE_p_giac__identificateur.getCPtr(x), withsqrt, context.getCPtr(arg3), arg3), true);
  }

  public static gen partfrac(gen e, gen f, boolean withsqrt, context arg3) {
    return new gen(giacJNI.partfrac__SWIG_3(gen.getCPtr(e), e, gen.getCPtr(f), f, withsqrt, context.getCPtr(arg3), arg3), true);
  }

  public static gen _partfrac(gen args, context arg1) {
    return new gen(giacJNI._partfrac(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _resultant(gen args, context arg1) {
    return new gen(giacJNI._resultant(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen cklvar(gen e, context arg1) {
    return new gen(giacJNI.cklvar(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen ckalgvar(gen e, context arg1) {
    return new gen(giacJNI.ckalgvar(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static boolean sym2r(gen e, SWIGTYPE_p_giac__vecteur l, SWIGTYPE_p_giac__vecteur lv, SWIGTYPE_p_giac__vecteur lvnum, SWIGTYPE_p_giac__vecteur lvden, int l_size, gen num, gen den, context arg8) {
    return giacJNI.sym2r__SWIG_0(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(l), SWIGTYPE_p_giac__vecteur.getCPtr(lv), SWIGTYPE_p_giac__vecteur.getCPtr(lvnum), SWIGTYPE_p_giac__vecteur.getCPtr(lvden), l_size, gen.getCPtr(num), num, gen.getCPtr(den), den, context.getCPtr(arg8), arg8);
  }

  public static boolean sym2r(gen e, SWIGTYPE_p_giac__vecteur l, int l_size, gen num, gen den, context arg5) {
    return giacJNI.sym2r__SWIG_1(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(l), l_size, gen.getCPtr(num), num, gen.getCPtr(den), den, context.getCPtr(arg5), arg5);
  }

  public static gen e2r(gen e, SWIGTYPE_p_giac__vecteur l, context arg2) {
    return new gen(giacJNI.e2r__SWIG_0(gen.getCPtr(e), e, SWIGTYPE_p_giac__vecteur.getCPtr(l), context.getCPtr(arg2), arg2), true);
  }

  public static gen e2r(gen e, gen x, context arg2) {
    return new gen(giacJNI.e2r__SWIG_1(gen.getCPtr(e), e, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _e2r(gen args, context arg1) {
    return new gen(giacJNI._e2r(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen r2sym(SWIGTYPE_p_giac__polynome p, SWIGTYPE_p_giac__vecteur l, context arg2) {
    return new gen(giacJNI.r2sym__SWIG_0(SWIGTYPE_p_giac__polynome.getCPtr(p), SWIGTYPE_p_giac__vecteur.getCPtr(l), context.getCPtr(arg2), arg2), true);
  }

  public static gen r2sym(gen p, SWIGTYPE_p_giac__vecteur l, context arg2) {
    return new gen(giacJNI.r2sym__SWIG_1(gen.getCPtr(p), p, SWIGTYPE_p_giac__vecteur.getCPtr(l), context.getCPtr(arg2), arg2), true);
  }

  public static gen r2e(gen p, SWIGTYPE_p_giac__vecteur l, context arg2) {
    return new gen(giacJNI.r2e__SWIG_0(gen.getCPtr(p), p, SWIGTYPE_p_giac__vecteur.getCPtr(l), context.getCPtr(arg2), arg2), true);
  }

  public static gen r2e(gen r, gen x, context arg2) {
    return new gen(giacJNI.r2e__SWIG_1(gen.getCPtr(r), r, gen.getCPtr(x), x, context.getCPtr(arg2), arg2), true);
  }

  public static gen _r2e(gen args, context arg1) {
    return new gen(giacJNI._r2e(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen r2sym(SWIGTYPE_p_giac__fraction f, SWIGTYPE_p_giac__vecteur l, context arg2) {
    return new gen(giacJNI.r2sym__SWIG_2(SWIGTYPE_p_giac__fraction.getCPtr(f), SWIGTYPE_p_giac__vecteur.getCPtr(l), context.getCPtr(arg2), arg2), true);
  }

  public static gen r2sym(SWIGTYPE_p_giac__factorization vnum, SWIGTYPE_p_giac__vecteur l, context arg2) {
    return new gen(giacJNI.r2sym__SWIG_3(SWIGTYPE_p_giac__factorization.getCPtr(vnum), SWIGTYPE_p_giac__vecteur.getCPtr(l), context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_std__string add_print(SWIGTYPE_p_std__string s, gen g, context arg2) {
    return new SWIGTYPE_p_std__string(giacJNI.add_print(SWIGTYPE_p_std__string.getCPtr(s), gen.getCPtr(g), g, context.getCPtr(arg2), arg2), false);
  }

  public static void evalfdouble2reim(gen a, gen e, gen f0, gen f1, context arg4) {
    giacJNI.evalfdouble2reim(gen.getCPtr(a), a, gen.getCPtr(e), e, gen.getCPtr(f0), f0, gen.getCPtr(f1), f1, context.getCPtr(arg4), arg4);
  }

  public static String gen2tex(gen e, context arg1) {
    return giacJNI.gen2tex(gen.getCPtr(e), e, context.getCPtr(arg1), arg1);
  }

  public static gen graph2tex(gen args, SWIGTYPE_p_giac__vecteur v, context arg2) {
    return new gen(giacJNI.graph2tex(gen.getCPtr(args), args, SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg2), arg2), true);
  }

  public static gen _graph2tex(gen args, context arg1) {
    return new gen(giacJNI._graph2tex(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _graph3d2tex(gen args, context arg1) {
    return new gen(giacJNI._graph3d2tex(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _latex(gen args, context arg1) {
    return new gen(giacJNI._latex(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _seq(gen g, context arg1) {
    return new gen(giacJNI._seq(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _logb(gen g, context arg1) {
    return new gen(giacJNI._logb(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _getType(gen g, context arg1) {
    return new gen(giacJNI._getType(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Define(gen g, context arg1) {
    return new gen(giacJNI._Define(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Input(gen args, context arg1) {
    return new gen(giacJNI._Input(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _InputStr(gen g, context arg1) {
    return new gen(giacJNI._InputStr(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Prompt(gen g, context arg1) {
    return new gen(giacJNI._Prompt(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cSolve(gen g, context arg1) {
    return new gen(giacJNI._cSolve(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cFactor(gen g, context arg1) {
    return new gen(giacJNI._cFactor(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cpartfrac(gen g, context arg1) {
    return new gen(giacJNI._cpartfrac(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _nSolve(gen g, context arg1) {
    return new gen(giacJNI._nSolve(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _zeros(gen g, context arg1) {
    return new gen(giacJNI._zeros(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cZeros(gen g, context arg1) {
    return new gen(giacJNI._cZeros(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _getDenom(gen g, context arg1) {
    return new gen(giacJNI._getDenom(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _getNum(gen g, context arg1) {
    return new gen(giacJNI._getNum(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _tExpand(gen g, context arg1) {
    return new gen(giacJNI._tExpand(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _comDenom(gen g, context arg1) {
    return new gen(giacJNI._comDenom(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _randPoly(gen g, context arg1) {
    return new gen(giacJNI._randPoly(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _nInt(gen g, context arg1) {
    return new gen(giacJNI._nInt(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _nDeriv(gen g, context arg1) {
    return new gen(giacJNI._nDeriv(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _avgRC(gen g, context arg1) {
    return new gen(giacJNI._avgRC(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fMin(gen g, context arg1) {
    return new gen(giacJNI._fMin(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fMax(gen g, context arg1) {
    return new gen(giacJNI._fMax(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _taylor(gen g, context arg1) {
    return new gen(giacJNI._taylor(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _arcLen(gen g, context arg1) {
    return new gen(giacJNI._arcLen(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _dim(gen g, context arg1) {
    return new gen(giacJNI._dim(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _format(gen g, context arg1) {
    return new gen(giacJNI._format(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inString(gen g, context arg1) {
    return new gen(giacJNI._inString(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _left(gen g, context arg1) {
    return new gen(giacJNI._left(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _right(gen g, context arg1) {
    return new gen(giacJNI._right(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mid(gen g, context arg1) {
    return new gen(giacJNI._mid(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ord(gen g, context arg1) {
    return new gen(giacJNI._ord(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rotate(gen g, context arg1) {
    return new gen(giacJNI._rotate(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _shift(gen g, context arg1) {
    return new gen(giacJNI._shift(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _augment(gen g, context arg1) {
    return new gen(giacJNI._augment(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _semi_augment(gen g, context arg1) {
    return new gen(giacJNI._semi_augment(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cumSum(gen g, context arg1) {
    return new gen(giacJNI._cumSum(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _exp2list(gen g, context arg1) {
    return new gen(giacJNI._exp2list(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _list2mat(gen g, context arg1) {
    return new gen(giacJNI._list2mat(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _deltalist(gen g, context arg1) {
    return new gen(giacJNI._deltalist(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mat2list(gen g, context arg1) {
    return new gen(giacJNI._mat2list(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _newList(gen g, context arg1) {
    return new gen(giacJNI._newList(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _polyEval(gen g, context arg1) {
    return new gen(giacJNI._polyEval(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _product(gen g, context arg1) {
    return new gen(giacJNI._product(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SortA(gen g, context arg1) {
    return new gen(giacJNI._SortA(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SortD(gen g, context arg1) {
    return new gen(giacJNI._SortD(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _int(gen g, context arg1) {
    return new gen(giacJNI._int(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _iPart(gen g, context arg1) {
    return new gen(giacJNI._iPart(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Fill(gen g, context arg1) {
    return new gen(giacJNI._Fill(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mRow(gen g, context arg1) {
    return new gen(giacJNI._mRow(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _mRowAdd(gen g, context arg1) {
    return new gen(giacJNI._mRowAdd(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rowAdd(gen g, context arg1) {
    return new gen(giacJNI._rowAdd(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rowSwap(gen g, context arg1) {
    return new gen(giacJNI._rowSwap(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _newMat(gen g, context arg1) {
    return new gen(giacJNI._newMat(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ref(gen a, context arg1) {
    return new gen(giacJNI._ref(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _subMat(gen g, context arg1) {
    return new gen(giacJNI._subMat(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _unitV(gen g, context arg1) {
    return new gen(giacJNI._unitV(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rowNorm(gen g, context arg1) {
    return new gen(giacJNI._rowNorm(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _colNorm(gen g, context arg1) {
    return new gen(giacJNI._colNorm(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Archive(gen g, context arg1) {
    return new gen(giacJNI._Archive(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Unarchiv(gen g, context arg1) {
    return new gen(giacJNI._Unarchiv(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ClrIO(gen g, context arg1) {
    return new gen(giacJNI._ClrIO(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Output(gen g, context arg1) {
    return new gen(giacJNI._Output(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _getKey(gen g, context arg1) {
    return new gen(giacJNI._getKey(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DelFold(gen g, context arg1) {
    return new gen(giacJNI._DelFold(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DispG(gen g, context arg1) {
    return new gen(giacJNI._DispG(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DispHome(gen g, context arg1) {
    return new gen(giacJNI._DispHome(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Exec(gen g, context arg1) {
    return new gen(giacJNI._Exec(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _NewFold(gen g, context arg1) {
    return new gen(giacJNI._NewFold(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _GetFold(gen g, context arg1) {
    return new gen(giacJNI._GetFold(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _StoPic(gen g, context arg1) {
    return new gen(giacJNI._StoPic(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RclPic(gen g, context arg1) {
    return new gen(giacJNI._RclPic(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RplcPic(gen g, context arg1) {
    return new gen(giacJNI._RplcPic(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ClrGraph(gen g, context arg1) {
    return new gen(giacJNI._ClrGraph(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _PtOn(gen g, context arg1) {
    return new gen(giacJNI._PtOn(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _PtOff(gen g, context arg1) {
    return new gen(giacJNI._PtOff(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Line(gen g, context arg1) {
    return new gen(giacJNI._Line(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _LineHorz(gen g, context arg1) {
    return new gen(giacJNI._LineHorz(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _LineVert(gen g, context arg1) {
    return new gen(giacJNI._LineVert(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _DrawSlp(gen g, context arg1) {
    return new gen(giacJNI._DrawSlp(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Circle(gen g, context arg1) {
    return new gen(giacJNI._Circle(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _PtText(gen g, context arg1) {
    return new gen(giacJNI._PtText(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _NewPic(gen g, context arg1) {
    return new gen(giacJNI._NewPic(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ZoomSto(gen g, context arg1) {
    return new gen(giacJNI._ZoomSto(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ZoomRcl(gen g, context arg1) {
    return new gen(giacJNI._ZoomRcl(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _deSolve(gen g, context arg1) {
    return new gen(giacJNI._deSolve(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _LineTan(gen g, context arg1) {
    return new gen(giacJNI._LineTan(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _CyclePic(gen g, context arg1) {
    return new gen(giacJNI._CyclePic(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _RandSeed(gen g, context arg1) {
    return new gen(giacJNI._RandSeed(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen exact(gen g, context arg1) {
    return new gen(giacJNI.exact(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen fPart(gen g, context arg1) {
    return new gen(giacJNI.fPart(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen simult(gen g, context arg1) {
    return new gen(giacJNI.simult(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _unarchive_ti(gen g, context arg1) {
    return new gen(giacJNI._unarchive_ti(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sialorssinon(gen g, context arg1) {
    return new gen(giacJNI._sialorssinon(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pour(gen g, context arg1) {
    return new gen(giacJNI._pour(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static String printsommetasoperator(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printsommetasoperator(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static String texprintsommetasoperator(gen feuille, String sommetstr, context arg2) {
    return giacJNI.texprintsommetasoperator(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static gen taylor(gen lim_point, int order, SWIGTYPE_p_giac__unary_function_ptr D, int direction, gen shift_coeff, context arg5) {
    return new gen(giacJNI.taylor(gen.getCPtr(lim_point), lim_point, order, SWIGTYPE_p_giac__unary_function_ptr.getCPtr(D), direction, gen.getCPtr(shift_coeff), shift_coeff, context.getCPtr(arg5), arg5), true);
  }

  public static gen apply(gen e, SWIGTYPE_p_giac__unary_function_ptr f, context arg2) {
    return new gen(giacJNI.apply(gen.getCPtr(e), e, SWIGTYPE_p_giac__unary_function_ptr.getCPtr(f), context.getCPtr(arg2), arg2), true);
  }

  public static gen frac_neg_out(gen g, context arg1) {
    return new gen(giacJNI.frac_neg_out(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _constant_one(gen args, context arg1) {
    return new gen(giacJNI._constant_one(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _constant_zero(gen args, context arg1) {
    return new gen(giacJNI._constant_zero(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rm_a_z(gen args, context arg1) {
    return new gen(giacJNI._rm_a_z(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _id(gen args, context arg1) {
    return new gen(giacJNI._id(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _not(gen args, context arg1) {
    return new gen(giacJNI._not(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _neg(gen args, context arg1) {
    return new gen(giacJNI._neg(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inv(gen args, context arg1) {
    return new gen(giacJNI._inv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen ln(gen e, context arg1) {
    return new gen(giacJNI.ln(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen log(gen e, context arg1) {
    return new gen(giacJNI.log(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen log10(gen e, context arg1) {
    return new gen(giacJNI.log10(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen alog10(gen e, context arg1) {
    return new gen(giacJNI.alog10(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen atan(gen e0, context arg1) {
    return new gen(giacJNI.atan(gen.getCPtr(e0), e0, context.getCPtr(arg1), arg1), true);
  }

  public static gen exp(gen e0, context arg1) {
    return new gen(giacJNI.exp(gen.getCPtr(e0), e0, context.getCPtr(arg1), arg1), true);
  }

  public static String gen2string(gen g, int format, context arg2) {
    return giacJNI.gen2string(gen.getCPtr(g), g, format, context.getCPtr(arg2), arg2);
  }

  public static String print_with_parenthesis_if_required(gen g, int format, context arg2) {
    return giacJNI.print_with_parenthesis_if_required(gen.getCPtr(g), g, format, context.getCPtr(arg2), arg2);
  }

  public static gen sqrt_noabs(gen e, context arg1) {
    return new gen(giacJNI.sqrt_noabs(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen sqrt(gen e, context arg1) {
    return new gen(giacJNI.sqrt(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen sqrt_mod(gen a, gen b, boolean isprime, context arg3) {
    return new gen(giacJNI.sqrt_mod(gen.getCPtr(a), a, gen.getCPtr(b), b, isprime, context.getCPtr(arg3), arg3), true);
  }

  public static gen sin(gen e, context arg1) {
    return new gen(giacJNI.sin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen cos(gen e, context arg1) {
    return new gen(giacJNI.cos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tan(gen e, context arg1) {
    return new gen(giacJNI.tan(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen asin(gen e, context arg1) {
    return new gen(giacJNI.asin(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen acos(gen e, context arg1) {
    return new gen(giacJNI.acos(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen sinh(gen e, context arg1) {
    return new gen(giacJNI.sinh(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen cosh(gen e, context arg1) {
    return new gen(giacJNI.cosh(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen tanh(gen e, context arg1) {
    return new gen(giacJNI.tanh(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen asinh(gen e, context arg1) {
    return new gen(giacJNI.asinh(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen acosh(gen e, context arg1) {
    return new gen(giacJNI.acosh(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen atanh(gen e, context arg1) {
    return new gen(giacJNI.atanh(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen quote(gen e, context arg1) {
    return new gen(giacJNI.quote(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen unquote(gen e, context arg1) {
    return new gen(giacJNI.unquote(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sign(gen g, context arg1) {
    return new gen(giacJNI._sign(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen order_size(gen e, context arg1) {
    return new gen(giacJNI.order_size(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _and(gen args, context arg1) {
    return new gen(giacJNI._and(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ou(gen args, context arg1) {
    return new gen(giacJNI._ou(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _xor(gen args, context arg1) {
    return new gen(giacJNI._xor(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen xor2(gen a, gen b, context arg2) {
    return new gen(giacJNI.xor2(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen _min(gen args, context arg1) {
    return new gen(giacJNI._min(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _max(gen args, context arg1) {
    return new gen(giacJNI._max(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _gcd(gen args, context arg1) {
    return new gen(giacJNI._gcd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _lcm(gen args, context arg1) {
    return new gen(giacJNI._lcm(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _egcd(gen args, context arg1) {
    return new gen(giacJNI._egcd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _iegcd(gen args, context arg1) {
    return new gen(giacJNI._iegcd(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _iquo(gen args, context arg1) {
    return new gen(giacJNI._iquo(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _irem(gen args, context arg1) {
    return new gen(giacJNI._irem(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quote_pow(gen args, context arg1) {
    return new gen(giacJNI._quote_pow(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _iquorem(gen args, context arg1) {
    return new gen(giacJNI._iquorem(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _smod(gen args, context arg1) {
    return new gen(giacJNI._smod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rdiv(gen args, context arg1) {
    return new gen(giacJNI._rdiv(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _is_prime(gen args, context arg1) {
    return new gen(giacJNI._is_prime(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _is_pseudoprime(gen args, context arg1) {
    return new gen(giacJNI._is_pseudoprime(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen nextprime1(gen a, context arg1) {
    return new gen(giacJNI.nextprime1(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen prevprime1(gen a, context arg1) {
    return new gen(giacJNI.prevprime1(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _jacobi_symbol(gen args, context arg1) {
    return new gen(giacJNI._jacobi_symbol(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _legendre_symbol(gen args, context arg1) {
    return new gen(giacJNI._legendre_symbol(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _floor(gen args, context arg1) {
    return new gen(giacJNI._floor(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ceil(gen args, context arg1) {
    return new gen(giacJNI._ceil(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen ceil2floor(gen g, context arg1) {
    return new gen(giacJNI.ceil2floor(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _round(gen args, context arg1) {
    return new gen(giacJNI._round(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _print(gen args, context arg1) {
    return new gen(giacJNI._print(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ichinrem(gen args, context arg1) {
    return new gen(giacJNI._ichinrem(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen double_is_int(gen g, context arg1) {
    return new gen(giacJNI.double_is_int(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _fracmod(gen args, context arg1) {
    return new gen(giacJNI._fracmod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _factorial(gen args, context arg1) {
    return new gen(giacJNI._factorial(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _perm(gen args, context arg1) {
    return new gen(giacJNI._perm(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen comb(gen n, gen k, context arg2) {
    return new gen(giacJNI.comb__SWIG_1(gen.getCPtr(n), n, gen.getCPtr(k), k, context.getCPtr(arg2), arg2), true);
  }

  public static gen _comb(gen args, context arg1) {
    return new gen(giacJNI._comb(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _chinrem(gen args, context arg1) {
    return new gen(giacJNI._chinrem(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _abs(gen args, context arg1) {
    return new gen(giacJNI._abs(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cyclotomic(gen a, context arg1) {
    return new gen(giacJNI._cyclotomic(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _calc_mode(gen args, context arg1) {
    return new gen(giacJNI._calc_mode(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quorem(gen args, context arg1) {
    return new gen(giacJNI._quorem(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _quo(gen args, context arg1) {
    return new gen(giacJNI._quo(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rem(gen args, context arg1) {
    return new gen(giacJNI._rem(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen sto(gen a, gen b, context arg2) {
    return new gen(giacJNI.sto__SWIG_0(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen sto(gen a, gen b, boolean in_place, context arg3) {
    return new gen(giacJNI.sto__SWIG_1(gen.getCPtr(a), a, gen.getCPtr(b), b, in_place, context.getCPtr(arg3), arg3), true);
  }

  public static boolean is_assumed_integer(gen g, context arg1) {
    return giacJNI.is_assumed_integer(gen.getCPtr(g), g, context.getCPtr(arg1), arg1);
  }

  public static gen giac_assume(gen a, context arg1) {
    return new gen(giacJNI.giac_assume(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen giac_additionally(gen a, context arg1) {
    return new gen(giacJNI.giac_additionally(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen doubleassume_and(SWIGTYPE_p_giac__vecteur v, gen a, int direction, boolean or_assumption, context arg4) {
    return new gen(giacJNI.doubleassume_and(SWIGTYPE_p_giac__vecteur.getCPtr(v), gen.getCPtr(a), a, direction, or_assumption, context.getCPtr(arg4), arg4), true);
  }

  public static gen _equal(gen args, context arg1) {
    return new gen(giacJNI._equal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _same(gen args, context arg1) {
    return new gen(giacJNI._same(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inferieur_strict(gen args, context arg1) {
    return new gen(giacJNI._inferieur_strict(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _inferieur_egal(gen args, context arg1) {
    return new gen(giacJNI._inferieur_egal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _superieur_strict(gen args, context arg1) {
    return new gen(giacJNI._superieur_strict(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _superieur_egal(gen args, context arg1) {
    return new gen(giacJNI._superieur_egal(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _different(gen args, context arg1) {
    return new gen(giacJNI._different(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen check_symb_of(gen a, gen b, context arg2) {
    return new gen(giacJNI.check_symb_of(gen.getCPtr(a), a, gen.getCPtr(b), b, context.getCPtr(arg2), arg2), true);
  }

  public static gen _of(gen args, context arg1) {
    return new gen(giacJNI._of(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _at(gen args, context arg1) {
    return new gen(giacJNI._at(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _table(gen args, context arg1) {
    return new gen(giacJNI._table(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _plus(gen args, context arg1) {
    return new gen(giacJNI._plus(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _prod(gen args, context arg1) {
    return new gen(giacJNI._prod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static String cprintaspow(gen feuille, String sommetstr_orig, context arg2) {
    return giacJNI.cprintaspow(gen.getCPtr(feuille), feuille, sommetstr_orig, context.getCPtr(arg2), arg2);
  }

  public static gen _pow(gen args, context arg1) {
    return new gen(giacJNI._pow(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _powmod(gen args, context arg1) {
    return new gen(giacJNI._powmod(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _eval(gen a, context arg1) {
    return new gen(giacJNI._eval(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _evalf(gen arg0, context arg1) {
    return new gen(giacJNI._evalf(gen.getCPtr(arg0), arg0, context.getCPtr(arg1), arg1), true);
  }

  public static gen _subst(gen args, context arg1) {
    return new gen(giacJNI._subst(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _subs(gen args, context arg1) {
    return new gen(giacJNI._subs(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _maple_subs(gen args, context arg1) {
    return new gen(giacJNI._maple_subs(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ampersand_times(gen g, context arg1) {
    return new gen(giacJNI._ampersand_times(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _version(gen a, context arg1) {
    return new gen(giacJNI._version(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen Gamma(gen x, context arg1) {
    return new gen(giacJNI.Gamma(gen.getCPtr(x), x, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Gamma(gen args, context arg1) {
    return new gen(giacJNI._Gamma(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen lngamma(gen x, context arg1) {
    return new gen(giacJNI.lngamma(gen.getCPtr(x), x, context.getCPtr(arg1), arg1), true);
  }

  public static gen Psi(gen x, context arg1) {
    return new gen(giacJNI.Psi__SWIG_0(gen.getCPtr(x), x, context.getCPtr(arg1), arg1), true);
  }

  public static gen Psi(gen x, int n, context arg2) {
    return new gen(giacJNI.Psi__SWIG_1(gen.getCPtr(x), x, n, context.getCPtr(arg2), arg2), true);
  }

  public static gen _Psi(gen args, context arg1) {
    return new gen(giacJNI._Psi(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen Zeta(gen x, context arg1) {
    return new gen(giacJNI.Zeta__SWIG_0(gen.getCPtr(x), x, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Zeta(gen args, context arg1) {
    return new gen(giacJNI._Zeta(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _erf(gen args, context arg1) {
    return new gen(giacJNI._erf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen erf(gen args, context arg1) {
    return new gen(giacJNI.erf(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _erfc(gen args, context arg1) {
    return new gen(giacJNI._erfc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen erfc(gen args, context arg1) {
    return new gen(giacJNI.erfc(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Ci(gen g, context arg1) {
    return new gen(giacJNI._Ci(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Si(gen g, context arg1) {
    return new gen(giacJNI._Si(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Ei(gen g, context arg1) {
    return new gen(giacJNI._Ei(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Heaviside(gen args, context arg1) {
    return new gen(giacJNI._Heaviside(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Dirac(gen args, context arg1) {
    return new gen(giacJNI._Dirac(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _multistring(gen args, context arg1) {
    return new gen(giacJNI._multistring(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _normalmod(gen g, context arg1) {
    return new gen(giacJNI._normalmod(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen alternate_series(gen a, gen x, int n, context arg3) {
    return new gen(giacJNI.alternate_series(gen.getCPtr(a), a, gen.getCPtr(x), x, n, context.getCPtr(arg3), arg3), true);
  }

  public static gen Eta(gen s, int ndiff, context arg2) {
    return new gen(giacJNI.Eta__SWIG_0(gen.getCPtr(s), s, ndiff, context.getCPtr(arg2), arg2), true);
  }

  public static gen Eta(gen s0, context arg1) {
    return new gen(giacJNI.Eta__SWIG_1(gen.getCPtr(s0), s0, context.getCPtr(arg1), arg1), true);
  }

  public static gen Zeta(gen x, int ndiff, context arg2) {
    return new gen(giacJNI.Zeta__SWIG_1(gen.getCPtr(x), x, ndiff, context.getCPtr(arg2), arg2), true);
  }

  public static gen _Eta(gen args, context arg1) {
    return new gen(giacJNI._Eta(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _erfs(gen g, context arg1) {
    return new gen(giacJNI._erfs(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SiCi_f(gen args, context arg1) {
    return new gen(giacJNI._SiCi_f(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _SiCi_g(gen args, context arg1) {
    return new gen(giacJNI._SiCi_g(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Ci0(gen args, context arg1) {
    return new gen(giacJNI._Ci0(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen _Ei_f(gen args, context arg1) {
    return new gen(giacJNI._Ei_f(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen Ei(gen args, context arg1) {
    return new gen(giacJNI.Ei__SWIG_0(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen Ei(gen args, int n, context arg2) {
    return new gen(giacJNI.Ei__SWIG_1(gen.getCPtr(args), args, n, context.getCPtr(arg2), arg2), true);
  }

  public static gen _Ei0(gen args, context arg1) {
    return new gen(giacJNI._Ei0(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static gen Ci_replace0(gen g, context arg1) {
    return new gen(giacJNI.Ci_replace0(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen Ei_replace0(gen g, context arg1) {
    return new gen(giacJNI.Ei_replace0(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static String printassubs(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printassubs(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static String printasmaple_subs(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printasmaple_subs(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static String printassto(gen feuille, String sommetstr, context arg2) {
    return giacJNI.printassto(gen.getCPtr(feuille), feuille, sommetstr, context.getCPtr(arg2), arg2);
  }

  public static gen _proot(gen e, context arg1) {
    return new gen(giacJNI._proot(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pcoeff(gen e, context arg1) {
    return new gen(giacJNI._pcoeff(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _peval(gen e, context arg1) {
    return new gen(giacJNI._peval(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen spread_convert(gen g, int g_row, int g_col, context arg3) {
    return new gen(giacJNI.spread_convert(gen.getCPtr(g), g, g_row, g_col, context.getCPtr(arg3), arg3), true);
  }

  public static boolean iscell(gen g, SWIGTYPE_p_int r, SWIGTYPE_p_int c, context arg3) {
    return giacJNI.iscell(gen.getCPtr(g), g, SWIGTYPE_p_int.getCPtr(r), SWIGTYPE_p_int.getCPtr(c), context.getCPtr(arg3), arg3);
  }

  public static SWIGTYPE_p_giac__matrice matrice_insert(SWIGTYPE_p_giac__matrice m, int insert_row, int insert_col, int nrows, int ncols, gen fill, context arg6) {
    return new SWIGTYPE_p_giac__matrice(giacJNI.matrice_insert(SWIGTYPE_p_giac__matrice.getCPtr(m), insert_row, insert_col, nrows, ncols, gen.getCPtr(fill), fill, context.getCPtr(arg6), arg6), true);
  }

  public static gen cross(gen g1, gen g2, context arg2) {
    return new gen(giacJNI.cross(gen.getCPtr(g1), g1, gen.getCPtr(g2), g2, context.getCPtr(arg2), arg2), true);
  }

  public static gen _tran(gen a, context arg1) {
    return new gen(giacJNI._tran(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen ckmtrace(gen a, context arg1) {
    return new gen(giacJNI.ckmtrace(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static boolean mrref(SWIGTYPE_p_giac__matrice a, SWIGTYPE_p_giac__matrice res, SWIGTYPE_p_giac__vecteur pivots, gen det, context arg4) {
    return giacJNI.mrref(SWIGTYPE_p_giac__matrice.getCPtr(a), SWIGTYPE_p_giac__matrice.getCPtr(res), SWIGTYPE_p_giac__vecteur.getCPtr(pivots), gen.getCPtr(det), det, context.getCPtr(arg4), arg4);
  }

  public static gen _rref(gen a, context arg1) {
    return new gen(giacJNI._rref(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _idn(gen e, context arg1) {
    return new gen(giacJNI._idn(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__vecteur vranm(int n, gen f, context arg2) {
    return new SWIGTYPE_p_giac__vecteur(giacJNI.vranm(n, gen.getCPtr(f), f, context.getCPtr(arg2), arg2), true);
  }

  public static SWIGTYPE_p_giac__matrice mranm(int n, int m, gen f, context arg3) {
    return new SWIGTYPE_p_giac__matrice(giacJNI.mranm(n, m, gen.getCPtr(f), f, context.getCPtr(arg3), arg3), true);
  }

  public static gen _ranm(gen e, context arg1) {
    return new gen(giacJNI._ranm(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _randvector(gen e, context arg1) {
    return new gen(giacJNI._randvector(gen.getCPtr(e), e, context.getCPtr(arg1), arg1), true);
  }

  public static gen _padic_linsolve(gen g, context arg1) {
    return new gen(giacJNI._padic_linsolve(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen mdet(SWIGTYPE_p_giac__matrice a, context arg1) {
    return new gen(giacJNI.mdet(SWIGTYPE_p_giac__matrice.getCPtr(a), context.getCPtr(arg1), arg1), true);
  }

  public static gen _det(gen a, context arg1) {
    return new gen(giacJNI._det(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _sylvester(gen a, context arg1) {
    return new gen(giacJNI._sylvester(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _hessenberg(gen g, context arg1) {
    return new gen(giacJNI._hessenberg(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pcar_hessenberg(gen g, context arg1) {
    return new gen(giacJNI._pcar_hessenberg(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _pcar(gen a, context arg1) {
    return new gen(giacJNI._pcar(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static boolean egv(SWIGTYPE_p_giac__matrice m, SWIGTYPE_p_giac__matrice p, SWIGTYPE_p_giac__vecteur d, context arg3, boolean jordan, boolean rational_jordan_form, boolean eigenvalues_only) {
    return giacJNI.egv(SWIGTYPE_p_giac__matrice.getCPtr(m), SWIGTYPE_p_giac__matrice.getCPtr(p), SWIGTYPE_p_giac__vecteur.getCPtr(d), context.getCPtr(arg3), arg3, jordan, rational_jordan_form, eigenvalues_only);
  }

  public static gen _egv(gen a, context arg1) {
    return new gen(giacJNI._egv(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _svd(gen a, context arg1) {
    return new gen(giacJNI._svd(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _egvl(gen a, context arg1) {
    return new gen(giacJNI._egvl(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _jordan(gen a, context arg1) {
    return new gen(giacJNI._jordan(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen jordan(gen a, boolean rational_jordan, context arg2) {
    return new gen(giacJNI.jordan(gen.getCPtr(a), a, rational_jordan, context.getCPtr(arg2), arg2), true);
  }

  public static gen _rat_jordan(gen a, context arg1) {
    return new gen(giacJNI._rat_jordan(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _rat_jordan_block(gen args, context arg1) {
    return new gen(giacJNI._rat_jordan_block(gen.getCPtr(args), args, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__matrice diagonal_apply(gen g, gen x, SWIGTYPE_p_giac__matrice m, context arg3) {
    return new SWIGTYPE_p_giac__matrice(giacJNI.diagonal_apply(gen.getCPtr(g), g, gen.getCPtr(x), x, SWIGTYPE_p_giac__matrice.getCPtr(m), context.getCPtr(arg3), arg3), true);
  }

  public static SWIGTYPE_p_giac__matrice analytic_apply(gen ux, gen x, SWIGTYPE_p_giac__matrice m, context arg3) {
    return new SWIGTYPE_p_giac__matrice(giacJNI.analytic_apply(gen.getCPtr(ux), ux, gen.getCPtr(x), x, SWIGTYPE_p_giac__matrice.getCPtr(m), context.getCPtr(arg3), arg3), true);
  }

  public static SWIGTYPE_p_giac__matrice matpow(SWIGTYPE_p_giac__matrice m, gen n, context arg2) {
    return new SWIGTYPE_p_giac__matrice(giacJNI.matpow(SWIGTYPE_p_giac__matrice.getCPtr(m), gen.getCPtr(n), n, context.getCPtr(arg2), arg2), true);
  }

  public static gen _matpow(gen a, context arg1) {
    return new gen(giacJNI._matpow(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ker(gen a, context arg1) {
    return new gen(giacJNI._ker(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _image(gen a, context arg1) {
    return new gen(giacJNI._image(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cross(gen a, context arg1) {
    return new gen(giacJNI._cross(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen lu(gen a, context arg1) {
    return new gen(giacJNI.lu(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen qr(gen a, context arg1) {
    return new gen(giacJNI.qr(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cholesky(gen a, context arg1) {
    return new gen(giacJNI._cholesky(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _basis(gen a, context arg1) {
    return new gen(giacJNI._basis(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ibasis(gen a, context arg1) {
    return new gen(giacJNI._ibasis(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen _cell(gen a, context arg1) {
    return new gen(giacJNI._cell(gen.getCPtr(a), a, context.getCPtr(arg1), arg1), true);
  }

  public static gen l2norm(SWIGTYPE_p_giac__vecteur v, context arg1) {
    return new gen(giacJNI.l2norm(SWIGTYPE_p_giac__vecteur.getCPtr(v), context.getCPtr(arg1), arg1), true);
  }

  public static gen _lll(gen g, context arg1) {
    return new gen(giacJNI._lll(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ihermite(gen g, context arg1) {
    return new gen(giacJNI._ihermite(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _ismith(gen g, context arg1) {
    return new gen(giacJNI._ismith(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static gen _csv2gen(gen g, context arg1) {
    return new gen(giacJNI._csv2gen(gen.getCPtr(g), g, context.getCPtr(arg1), arg1), true);
  }

  public static SWIGTYPE_p_giac__matrice csv2gen(SWIGTYPE_p_std__istream i, char sep, char nl, char decsep, char eof, context arg5) {
    return new SWIGTYPE_p_giac__matrice(giacJNI.csv2gen(SWIGTYPE_p_std__istream.getCPtr(i), sep, nl, decsep, eof, context.getCPtr(arg5), arg5), true);
  }

}
