passagemath-singular 10.6.31rc3__cp314-cp314-musllinux_1_2_x86_64.whl

sage_wheels/share/singular/LIB/orbitparam.lib

@@ -0,0 +1,351 @@
+//////////////////////////////////////////////////////////////////////////////
+version="version orbitparam.lib 4.1.2.0 Feb_2019 "; // $Id: 0404076cf29a9a8402af8b496b751f0a9f3814b5 $
+category="Algebraic Geometry";
+info="
+LIBRARY:  orbitparam.lib   Parametrizing orbits of unipotent actions
+
+AUTHORS:  J. Boehm, boehm at mathematik.uni-kl.de @*
+          S. Papadakis, papadak at math.ist.utl.pt @*
+
+OVERVIEW:
+
+This library implements the theorem of Chevalley-Rosenlicht as stated in Theorem 3.1.4 of [Corwin, Greenleaf].
+Given a set of strictly upper triangular n x n matrices L_1,...,L_c which generate
+a Lie algebra as a vector space, and a vector v of size n, the
+function @code{parametrizeOrbit} constructs a parametrization of the orbit of v under
+the action of exp(<L_1,...,L_c>).
+
+To compute exp of the Lie algebra elements corresponding
+to the parameters we require that the characteristic of the base field is zero or larger than n.
+
+By determining the parameters from bottom to top
+this allows you to find an element in the orbit with (at least) as many zeros as the dimension of the
+orbit.
+
+Note: Theorem 3.1.4 of [Corwin, Greenleaf] uses strictly lower triangular matrices.
+
+REFERENCES:
+
+Laurence Corwin, Frederick P. Greenleaf: Representations of Nilpotent Lie Groups and their Applications: Volume 1, Part 1, Basic Theory and Examples, Cambridge University Press (2004).
+
+PROCEDURES:
+
+tangentGens(list,matrix);         Returns elements in the Lie algebra, which form a basis of the tangent space of the parametrization.
+matrixExp(matrix);                Matrix exp for nilpotent matrices.
+matrixLog(matrix);                Matrix log for unipotent matrices.
+parametrizeOrbit(list,matrix);    Returns parametrization of the orbit.
+maxZeros(list,matrix);            Determine an element in the orbit with the maximum number of zeroes.
+
+KEYWORDS: nilpotent Lie algebras; unipotent groups; orbit; parametrization; Chevalley-Rosenlicht theorem
+";
+
+LIB "general.lib";
+LIB "matrix.lib";
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+proc tangentGens(list L, matrix v)
+"USAGE:  tangentGens(L,v); L list, v matrix.
+ASSUME:  L is a list of strictly upper triangular n x n matrices of same size.
+         The vector space <L> generated by the elements of L should be closed
+         under the Lie bracket.
+
+         v is matrix of constants of size n x 1.
+
+RETURN:  list, with four entries
+@*       - first entry is the dimension of the orbit of under the action of exp(<L>)
+@*       - second entry is a list generators of the tangent space of the orbit of v at v
+           under the action of exp(<L>). If the characteristic p of the ground field is positive, then n has to be smaller than p. The generators are elements of <L>.
+@*       - third entry is the list of matrices with the coefficient to obtain the generators
+           as a linear combination of the elements of L
+@*       - fourth entry is list of integers with entries in v which can be made zero by the
+           action of exp(<L>)
+
+THEORY:  We apply the theorem of Chevalley-Rosenlicht.
+
+KEYWORDS: Lie algebra; orbit; Chevalley-Rosenlicht theorem
+
+EXAMPLE: example tangentGens; shows an example
+
+"
+{
+list T;
+list M;
+int i;
+int s;
+int t;
+list Z;
+int d=size(L);
+int n=nrows(v);
+  if (d<1){ERROR("expected nonempty list of generators");}
+  if (n<>nrows(L[1])){ERROR("vector should be same dimension as size of matrix");}
+  matrix A= L[1]*v;
+  for ( i=2; i <= d; i++ )
+  {
+    A=concat(A,L[i]*v);
+  }
+  matrix B;
+  for ( i=n-1; i >=1; i=i-1 )
+  {
+    B=submat(A,i..n,1..d);
+    matrix E[n-i+1][1];
+    E[1,1]=1;
+    list LU=ludecomp(B);
+    list Q=lusolve(LU[1],LU[2],LU[3],E);
+    if (Q[1]<>0){
+       s++;
+       T[s]=Q[2];
+       matrix C = Q[2][1,1]*L[1];
+       for ( t=2; t <= d; t++ )
+       {
+          C=C+Q[2][t,1]*L[t];
+       }
+       M[s]=C;
+       Z[s]=i;
+       kill C;
+    }
+    kill E,LU,Q;
+  }
+return(list(s,M,T,Z));
+}
+
+example
+{ "EXAMPLE:";
+  ring R = 0,(x),dp;
+  matrix L1[3][3] = 0,1,0, 0,0,0, 0,0,0;
+  matrix L2[3][3] = 0,0,1, 0,0,0, 0,0,0;
+  matrix L3[3][3] = 0,1,1, 0,0,1, 0,0,0;
+  list L = L1,L2,L3;
+  matrix v[3][1] = 1,2,3;
+  tangentGens(L,v);
+}
+
+
+proc matrixExp(matrix A)
+"USAGE:  matrixExp(A); A matrix.
+ASSUME:  A is a nilpotent n x n matrix.
+         If the characteristic p of the ground field is positive, then n has to be
+         smaller than p.
+
+RETURN:  matrix, exp(A)
+
+THEORY:  We compute the power series, which terminates since A is nilpotent.
+
+KEYWORDS: Exp for matrices
+
+EXAMPLE: example matrixExp; shows an example
+
+"
+{
+int i;
+int n = nrows(A);
+if (n<>ncols(A)){
+   ERROR("expected square matrix");
+}
+matrix Z[n][n];
+matrix B[n][n];
+B=B+1;
+matrix D[n][n];
+D=D+1;
+number j=1;
+for (i=1; i <= n; i++ )
+  {
+      j=j*i;
+      D=D*A;
+      if (D==Z){break;}
+      B=B+(1/j)*D;
+  }
+return(B);}
+example
+{ "EXAMPLE:";
+  ring R = 0,(x),dp;
+  matrix A[4][4] = 0,0,1,0, 0,0,1,0, 0,0,0,0;
+  matrixExp(A);
+}
+
+
+proc matrixLog(matrix A)
+"USAGE:  matrixLog(A); A matrix.
+ASSUME:  A-E is a nilpotent n x n matrix.
+         If the characteristic p of the ground field is positive, then n has to be
+         smaller than p.
+
+RETURN:  matrix, log(A)
+
+THEORY:  We compute the power series, which terminates since A-E is nilpotent.
+
+KEYWORDS: Log for matrices
+
+EXAMPLE: example matrixLog; shows an example
+
+"
+{
+int i;
+int n = nrows(A);
+if (n<>ncols(A)){
+   ERROR("expected square matrix");
+}
+matrix Z[n][n];
+matrix B[n][n];
+matrix D[n][n];
+matrix N[n][n]= A-1;
+D=D+1;
+number j;
+for (i=1; i <= n; i++ )
+  {
+      j=j+1;
+      D=D*N;
+      if (D==Z){break;}
+      B=B+(1/j)*(-1)^(i+1)*D;
+  }
+return(B);}
+example
+{ "EXAMPLE:";
+  ring R = 0,(s,t),dp;
+  matrix A[3][3] = 1,s,st/2, 0,1,t, 0,0,1;
+  matrixLog(A);
+}
+
+
+
+proc parametrizeOrbit(list L, matrix v)
+"USAGE:  parametrizeOrbit(L,v); L list, v matrix.
+ASSUME:  L is a list of strictly upper triangular n x n matrices of same size.
+         The vector space <L> generated by the elements of L should be closed
+         under the Lie bracket.
+@*       v is matrix of constants of size n x 1.
+@*       The basering has at least size(L) variables. However we will only use
+         tangentGens(L,v)[1] many of them.
+
+RETURN:  list, with four entries
+@*       - int, dimension of the orbit
+@*       - matrix A over the basering giving a parametrization of the orbit of v under the action of exp(<L>).
+@*       - list of integers, with the (row)-indices of entries which can be deleted by the action
+@*       - the variables of the parametrization to solve for
+
+THEORY:  We apply the theorem of Chevalley-Rosenlicht. First we determine tangent space generators,
+         then apply @code{matrixExp} to the generators, and finally take the product
+         to obtain the parametrization.
+
+KEYWORDS: Lie group; orbit; parametrization
+
+EXAMPLE: example parametrizeOrbit; shows an example
+"
+{
+list T = tangentGens(L,v);
+list T2 = T[2];
+int i;
+int d=size(L);
+list vL;
+if (nvars(basering)<d)
+{
+   ERROR("expected basering with at least generators many variables");
+}
+for (i=1; i <= size(T2); i++ )
+  {
+    v = matrixExp(T2[size(T2)-i+1]*var(size(T2)-i+1))*v;
+    vL[i]=var(i);
+  }
+return(list(T[1],v,T[4],vL));
+}
+
+example
+{ "EXAMPLE:";
+  ring R = 0,(t(1..3)),dp;
+  matrix L1[3][3] = 0,1,0, 0,0,0, 0,0,0;
+  matrix L2[3][3] = 0,0,1, 0,0,0, 0,0,0;
+  matrix L3[3][3] = 0,1,1, 0,0,1, 0,0,0;
+  list L = L1,L2,L3;
+  matrix v[3][1] = 1,2,3;
+  parametrizeOrbit(L,v);
+
+  ring R1 = 0,(t(1..2)),dp;
+  matrix L1[4][4] = 0,1,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0;
+  matrix L2[4][4] = 0,0,1,0, 0,0,0,1, 0,0,0,0, 0,0,0,0;
+  list L = L1,L2;
+  matrix v[4][1] = 1,2,3,4;
+  parametrizeOrbit(L,v);
+}
+
+
+proc maxZeros(list L, matrix v)
+"USAGE:  maxZeros(L,v); L list, v matrix.
+ASSUME:  L is a list of strictly upper triangular n x n matrices of same size.
+         The vector space <L> generated by the elements of L should be closed
+         under the Lie bracket.
+
+         v is matrix of constants of size n x 1.
+
+         The basering has at least size(L) variables. However we will only use
+         tangentGens(L,v)[1] many of them.
+
+RETURN:  matrix of constants over the basering giving an element in the orbit of v
+         under the action of exp(<L>)  with (at least) as many zeros as the dimension of the
+         orbit.
+
+THEORY:  We apply @code{parametrizeOrbit} to obtain a parametrization of the orbit
+         according to the theorem of Chevalley-Rosenlicht. By determining the parameters from bottom to top
+         we find an element in the orbit with (at least) as many zeros as the dimension of the
+         orbit.
+
+KEYWORDS: Lie group; orbit; maximum number of zeroes
+
+EXAMPLE: example parametrizeOrbit; shows an example
+"
+{
+  int d = size(L);
+  def Roriginal = basering;
+  list rl = ringlist(Roriginal);
+  int k;
+  for(k = 1; k <= d; k++)
+     {
+        rl[2][k] = "x("+string(k)+")";
+     }
+  rl[3]= list(list("dp",1:(d)),list("C",0));
+  def R = ring(rl);
+  setring R;
+  list L = fetch(Roriginal,L);
+  matrix v = fetch(Roriginal,v);
+  list P = parametrizeOrbit(L,v);
+  matrix p = P[2];
+  int n = P[1];
+  list idx = P[3];
+  list va = P[4];
+  poly equ,rhs;
+  number de;
+  list parval;
+  for(k = 1; k <= n; k++)
+     {
+        equ = p[idx[k],1];
+        rhs=-number(subst(equ,va[k],0));
+        de = number(diff (equ, va[k]));
+        parval[k] = rhs/de;
+        p = subst(p,va[k],rhs/de);
+     }
+  setring(Roriginal);
+  matrix p=fetch(R,p);
+  return(p);
+}
+
+example
+{ "EXAMPLE:";
+  ring R = 0,(x),dp;
+  matrix L1[3][3] = 0,1,0, 0,0,0, 0,0,0;
+  matrix L2[3][3] = 0,0,1, 0,0,0, 0,0,0;
+  matrix L3[3][3] = 0,1,1, 0,0,1, 0,0,0;
+  list L = L1,L2,L3;
+  matrix v[3][1] = 1,2,3;
+  maxZeros(L,v);
+
+  ring R1 = 0,(x),dp;
+  matrix L1[4][4] = 0,1,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0;
+  matrix L2[4][4] = 0,0,1,0, 0,0,0,1, 0,0,0,0, 0,0,0,0;
+  list L = L1,L2;
+  matrix v[4][1] = 1,2,3,4;
+  maxZeros(L,v);
+}
+
+

sage_wheels/share/singular/LIB/parallel.lib

@@ -0,0 +1,319 @@
+////////////////////////////////////////////////////////////////////
+version="version parallel.lib 4.4.1.1 Feb_2025 "; // $Id: a5e93aee5a9d3333810fc57b6fd047fa89e9f5b9 $
+category="General purpose";
+info="
+LIBRARY:   parallel.lib  An abstraction layer for parallel skeletons
+
+AUTHOR:    Andreas Steenpass, e-mail: steenpass@mathematik.uni-kl.de
+
+OVERVIEW:
+This library provides implementations of several parallel 'skeletons' (i.e.
+ways in which parallel tasks rely upon and interact with each other). It is
+based on the library tasks.lib and aims at both ordinary Singular users as well
+as authors of Singular libraries.
+
+KEYWORDS:  parallelization; parallel skeletons; distributed computing
+
+SEE ALSO:  resources_lib, tasks_lib, modstd_lib, normal_lib
+
+PROCEDURES:
+  parallelWaitN();      execute several jobs in parallel
+                        and wait for N of them to finish
+  parallelWaitFirst();  execute several jobs in parallel
+                        and wait for the first to finish
+  parallelWaitAll();    execute several jobs in parallel
+                        and wait for all of them to finish
+  parallelTestAND();    run several tests in parallel
+                        and determine if they all succeed
+  parallelTestOR();     run several tests in parallel
+                        and determine if any of them succeeds
+";
+
+LIB "tasks.lib";
+
+proc parallelWaitN(alias list commands, alias list args, int N, list #)
+"USAGE:   parallelWaitN(commands, arguments, N[, timeout]); commands list,
+          arguments list, N int, timeout int
+RETURN:   a list, containing the results of commands[i] applied to
+          arguments[i], i = 1, ..., size(arguments).
+       @* The procedure waits for N jobs to finish.
+       @* An optional timeout in ms can be provided. Default is 0 which
+          disables the timeout.
+NOTE:     The entries of the list commands must be strings. The entries of the
+          list arguments must be lists.
+       @* The type of any entry of the returned list whose corresponding task
+          did not finish (due to timeout or error) is \"none\".
+       @* The returned list may contain more than N results if several jobs
+          finished \"at the same time\". It may contain less than N results in
+          the case of timeout or errors occurring.
+SEE ALSO: parallelWaitAll, parallelWaitFirst, tasks_lib
+EXAMPLE:  example parallelWaitN; shows an example"
+{
+    // auxiliary variables
+    int i;
+
+    // read optional parameters
+    int timeout;
+    int ncores;   // obsolete, but kept for compatibility with old libraries
+    if (size(#) > 0) {
+        if (typeof(#[1]) != "int") {
+            ERROR("wrong optional parameters");
+        }
+        timeout = #[1];
+        if (size(#) > 1) {
+            if (size(#) > 2 || typeof(#[2]) != "int") {
+                ERROR("wrong optional parameters");
+            }
+            ncores = #[2];
+        }
+    }
+
+    // apply wrapper for obsolete optional parameter ncores
+    if (ncores) {
+        list semaphore_save = Resources::setcores_subtree(ncores);
+    }
+
+    // error checking
+    int njobs = size(commands);
+    if (njobs != size(args)) {
+        ERROR("The number of commands does not match the number of lists"
+            +newline+"of arguments.");
+    }
+    if (njobs == 0) {
+        ERROR("no commands specified");
+    }
+    for (i = 1; i <= njobs; i++) {
+        if (typeof(commands[i]) != "string") {
+            ERROR("The first argument is not a list of strings.");
+        }
+        if (typeof(args[i]) != "list") {
+            ERROR("The second argument is not a list of lists.");
+        }
+    }
+
+    list results;
+    if(system("cpu")<=1)
+    {
+      list tmp;
+      int tmp_s;
+      for(i=njobs;i>0;i--)
+      {
+        tmp=args[i];
+        tmp_s=size(tmp);
+        execute("results[i]="+commands[i]+"(tmp[1..tmp_s]);");
+      }
+    }
+    else
+    {
+      // compute the tasks
+      for (i = 1; i <= njobs; i++) {
+        task t(i) = commands[i], args[i];
+      }
+      startTasks(t(1..njobs));
+      list indices = waitTasks(list(t(1..njobs)), N, timeout);
+
+      // wrap back to saved semaphore
+      if (ncores) {
+        Resources::resetcores_subtree(semaphore_save);
+      }
+
+      // return results
+      for (i = size(indices); i > 0; i--) {
+        results[indices[i]] = getResult(t(indices[i]));
+      }
+      for (i = 1; i <= njobs; i++) {
+        killTask(t(i));
+      }
+    }
+    return(results);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R = 0, (x,y,z), lp;
+    ideal I = 3x3y+x3+xy3+y2z2, 2x3z-xy-xz3-y4-z2, 2x2yz-2xy2+xz2-y4;
+    ideal J = x10+x9y2, x2y7-y8;
+    list commands = list("std", "std");
+    list arguments = list(list(I), list(J));
+    parallelWaitN(commands, arguments, 1);
+}
+
+proc parallelWaitFirst(alias list commands, alias list args, list #)
+"USAGE:   parallelWaitFirst(commands, args[, timeout]); commands list,
+          arguments list, timeout int
+RETURN:   a list, containing at least one (if no timeout occurs) of the results
+          of commands[i] applied to arguments[i], i = 1, ..., size(arguments).
+       @* The command @code{parallelWaitFirst(commands, arguments[, timeout])}
+          is synonymous to
+          @code{parallelWaitN(commands, arguments, 1[, timeout])}. See
+          @ref{parallelWaitN} for details on optional arguments and other
+          remarks.
+SEE ALSO: parallelWaitN, parallelWaitAll, tasks_lib
+EXAMPLE:  example parallelWaitFirst; shows an example"
+{
+    return(parallelWaitN(commands, args, 1, #));
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R = 0, (x,y,z), lp;
+    ideal I = 3x3y+x3+xy3+y2z2, 2x3z-xy-xz3-y4-z2, 2x2yz-2xy2+xz2-y4;
+    ideal J = x10+x9y2, x2y7-y8;
+    list commands = list("std", "std");
+    list arguments = list(list(I), list(J));
+    parallelWaitFirst(commands, arguments);
+}
+
+proc parallelWaitAll(alias def commands, alias list args, list #)
+"USAGE:   parallelWaitAll(commands, arguments[, timeout]); commands list or
+          string, arguments list, timeout int
+RETURN:   a list, containing the results of commands[i] applied to
+          arguments[i], i = 1, ..., size(arguments).
+       @* The command @code{parallelWaitAll(commands, arguments[, timeout])} is
+          synonymous to @code{parallelWaitN(commands, arguments,
+          size(arguments)[, timeout])}. See @ref{parallelWaitN} for details on
+          optional arguments and other remarks.
+NOTE:     As a shortcut, @code{commands} can be a string. This is synonymous to
+          providing a list of @code{size(arguments)} copies of this string.
+SEE ALSO: parallelWaitFirst, parallelWaitN, tasks_lib
+EXAMPLE:  example parallelWaitAll; shows an example"
+{
+    if (typeof(commands) != "list" && typeof(commands) != "string") {
+        ERROR("invalid type of first argument");
+    }
+    if (typeof(commands) == "list") {
+        return(parallelWaitN(commands, args, size(args), #));
+    }
+    else {
+        list cmds;
+        for (int i = size(args); i > 0; i--) {
+            cmds[i] = commands;
+        }
+        return(parallelWaitN(cmds, args, size(args), #));
+    }
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R = 0, (x,y,z), dp;
+    ideal I1 = z8+z6+4z5+4z3+4z2+4, -z2+y;
+    ideal I2 = x9y2+x10, x2y7-y8;
+    ideal I3 = x3-2xy, x2y-2y2+x;
+    string command = "std";
+    list arguments = list(list(I1), list(I2), list(I3));
+    parallelWaitAll(command, arguments);
+}
+
+proc parallelTestAND(alias def commands, alias list args, list #)
+"USAGE:   parallelTestAND(commands, arguments[, timeout]); commands list or
+          string, arguments list, timeout int
+RETURN:   1, if commands[i] applied to arguments[i] is not equal to zero for
+          all i = 1, ..., size(arguments);
+          0, otherwise.
+       @* An optional timeout in ms can be provided. Default is 0 which
+          disables the timeout. In case of timeout, -1 is returned.
+NOTE:     The entries of the list commands must be strings. The entries of the
+          list arguments must be lists.
+       @* commands[i] applied to arguments[i] must evaluate to an integer for
+          i = 1, ..., size(arguments).
+       @* As a shortcut, @code{commands} can be a string. This is synonymous to
+          providing a list of @code{size(arguments)} copies of this string.
+SEE ALSO: parallelTestOR, tasks_lib
+EXAMPLE:  example parallelTestAND; shows an example"
+{
+    // note: this can be improved
+    list results = parallelWaitAll(commands, args, #);
+    int i;
+    for (i = size(args); i > 0; i--) {
+        if (typeof(results[i]) != "int" && typeof(results[i]) != "none") {
+            ERROR("result no. "+string(i)+" not of type int");
+        }
+    }
+    for (i = size(args); i > 0; i--) {
+        if (typeof(results[i]) == "none") {   // timeout
+            return(-1);
+        }
+    }
+    for (i = size(results); i > 0; i--) {
+        if (!results[i]) {
+            return(0);
+        }
+    }
+    return(1);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R = 0, (x,y,z), dp;
+    ideal I = x, y, z;
+    intvec v = 0:3;
+    list l = list(I, v);
+    module m1 = x*gen(1);
+    module m2;
+    string command = "size";
+    list arguments1 = list(list(I), list(v), list(l), list(m1));
+    list arguments2 = list(list(I), list(v), list(l), list(m2));
+    // test if all the arguments have non-zero size
+    parallelTestAND(command, arguments1);
+    parallelTestAND(command, arguments2);
+}
+
+proc parallelTestOR(alias def commands, alias list args, list #)
+"USAGE:   parallelTestOR(commands, arguments[, timeout]); commands list or
+          string, arguments list, timeout int
+RETURN:   1, if commands[i] applied to arguments[i] is not equal to zero for
+          any i = 1, ..., size(arguments);
+          0, otherwise.
+       @* An optional timeout in ms can be provided. Default is 0 which
+          disables the timeout. In case of timeout, -1 is returned.
+NOTE:     The entries of the list commands must be strings. The entries of the
+          list arguments must be lists.
+       @* commands[i] applied to arguments[i] must evaluate to an integer for
+          i = 1, ..., size(arguments).
+       @* As a shortcut, @code{commands} can be a string. This is synonymous to
+          providing a list of @code{size(arguments)} copies of this string.
+SEE ALSO: parallelTestAND, tasks_lib
+EXAMPLE:  example parallelTestAND; shows an example"
+{
+    // note: this can be improved
+    list results = parallelWaitAll(commands, args, #);
+    int i;
+    for (i = size(args); i > 0; i--) {
+        if (typeof(results[i]) != "int" && typeof(results[i]) != "none") {
+            ERROR("result no. "+string(i)+" not of type int");
+        }
+    }
+    for (i = size(args); i > 0; i--) {
+        if (typeof(results[i]) == "none") {   // timeout
+            return(-1);
+        }
+    }
+    for (i = size(results); i > 0; i--) {
+        if (results[i]) {
+            return(1);
+        }
+    }
+    return(0);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R = 0, (x,y,z), dp;
+    ideal I;
+    string s;
+    list l;
+    module m1 = x*gen(1);
+    module m2;
+    string command = "size";
+    list arguments1 = list(list(I), list(s), list(l), list(m1));
+    list arguments2 = list(list(I), list(s), list(l), list(m2));
+    // test if any of the arguments has non-zero size
+    parallelTestOR(command, arguments1);
+    parallelTestOR(command, arguments2);
+}
+