No, this is because your sketch uses code outside a method but includes methods in the sketch.

Either remove all methods.

Or use at least setup() - and if needed draw() - and make sure all calls are done within methods.

In other words, the special static mode is itself a big method inside sketch's class.

hmm...I'm afraid I don't understand...
I found this code that someone else wrote (probably somebody on this forum...maybe you)  that writes permutations.
And I need the permutations for another project I'm writing myself...on which you guys already helped me ;)

this is the code and i need to write it to text file...

 

int[] indices;
    String[] elements = {
      "1 ", "2 ", "3 ", "4 " 
    };
    PermutationGenerator x = new PermutationGenerator (elements.length);
    StringBuffer permutation;
     saveStrings("data.txt", permutation);

    void setup() {
 
      while (x.hasMore()) {
        permutation = new StringBuffer ();
        indices = x.getNext ();
        for (int i = 0; i < indices.length; i++) {
          permutation.append (elements[indices[i]]);
        }
        println (permutation.toString ());
      }
    }


    import java.math.BigInteger;

    class PermutationGenerator {

      int[] a;
      BigInteger numLeft;
      BigInteger total;

      //-----------------------------------------------------------
      // Constructor. WARNING: Don't make n too large.
      // Recall that the number of permutations is n!
      // which can be very large, even when n is as small as 20 --
      // 20! = 2,432,902,008,176,640,000 and
      // 21! is too big to fit into a Java long, which is
      // why we use BigInteger instead.
      //----------------------------------------------------------

      PermutationGenerator (int n) {
        if (n < 1) {
          throw new IllegalArgumentException ("Min 1");
        }
        a = new int[n];
        total = getFactorial (n);
        reset ();
 
      }

      //------
      // Reset
      //------

      void reset () {
        for (int i = 0; i < a.length; i++) {
          a[i] = i;
        }
        numLeft = new BigInteger (total.toString ());
      }

      //------------------------------------------------
      // Return number of permutations not yet generated
      //------------------------------------------------

      BigInteger getNumLeft () {
        return numLeft;
      }

      //------------------------------------
      // Return total number of permutations
      //------------------------------------

      BigInteger getTotal () {
        return total;
      }

      //-----------------------------
      // Are there more permutations?
      //-----------------------------

      boolean hasMore () {
        return numLeft.compareTo (BigInteger.ZERO) == 1;
      }

      //------------------
      // Compute factorial
      //------------------

      BigInteger getFactorial (int n) {
        BigInteger fact = BigInteger.ONE;
        for (int i = n; i > 1; i--) {
          fact = fact.multiply (new BigInteger (Integer.toString (i)));
        }
        return fact;
      }

      //--------------------------------------------------------
      // Generate next permutation (algorithm from Rosen p. 284)
      //--------------------------------------------------------

      int[] getNext () {

        if (numLeft.equals (total)) {
          numLeft = numLeft.subtract (BigInteger.ONE);
          return a;
        }

        int temp;

        // Find largest index j with a[j] < a[j+1]

        int j = a.length - 2;
        while (a[j] > a[j+1]) {
          j--;
        }

        // Find index k such that a[k] is smallest integer
        // greater than a[j] to the right of a[j]

        int k = a.length - 1;
        while (a[j] > a[k]) {
          k--;
        }

        // Interchange a[j] and a[k]

        temp = a[k];
        a[k] = a[j];
        a[j] = temp;

        // Put tail end of permutation after jth position in increasing order

        int r = a.length - 1;
        int s = j + 1;

        while (r > s) {
          temp = a[s];
          a[s] = a[r];
          a[r] = temp;
          r--;
          s++;
        }

        numLeft = numLeft.subtract (BigInteger.ONE);
        return a;
 
      }
     
    }

thanx for your previous help...I'll try to understand it later

The saveStrings() is outside of a function. It should be at the end of the computation of the permutations.
And you probably want
saveStrings("data.txt", permutation.toString());
instead.

Thanx for the response!

But when I put the saveStrings at the end of the computation it says:

The method saveStrings(String, String[]) in the type PApplet is not applicable for the arguments (String, String).

Ah, yes, saveStrings() wants an array of strings... Small annoyance. Try:
saveStrings("data.txt", new String[] { permutation.toString() });
for example...

Then he only writes the last permutation

But thanx alot! ...helps me a little further I guess

I'm stuck, and I really don't know what to do ...arff...
 
so this is the code I found and I added the line you gave me. But it only writes the last permutation (4 3 2 1)
 

    int[] indices;
    String[] elements = {
      "1 ", "2 ", "3 ", "4 " 
    };
    PermutationGenerator x = new PermutationGenerator (elements.length);
    StringBuffer permutation;
   
    void setup() {
      while (x.hasMore()) {
        permutation = new StringBuffer ();
        indices = x.getNext ();
        for (int i = 0; i < indices.length; i++) {
          permutation.append (elements[indices[i]]);
       }
        println (permutation.toString ());
        saveStrings("data.txt", new String[ ] {permutation.toString()});
      }
    }


    import java.math.BigInteger;

    class PermutationGenerator {
 
      int[] a;
      BigInteger numLeft;
      BigInteger total;

      //-----------------------------------------------------------
      // Constructor. WARNING: Don't make n too large.
      // Recall that the number of permutations is n!
      // which can be very large, even when n is as small as 20 --
      // 20! = 2,432,902,008,176,640,000 and
      // 21! is too big to fit into a Java long, which is
      // why we use BigInteger instead.
      //----------------------------------------------------------

      PermutationGenerator (int n) {
        if (n < 1) {
          throw new IllegalArgumentException ("Min 1");
        }
        a = new int[n];
        total = getFactorial (n);
        reset ();
      }

      //------
      // Reset
      //------

      void reset () {
        for (int i = 0; i < a.length; i++) {
          a[i] = i;
        }
        numLeft = new BigInteger (total.toString ());
      }

      //------------------------------------------------
      // Return number of permutations not yet generated
      //------------------------------------------------

      BigInteger getNumLeft () {
        return numLeft;
      }

      //------------------------------------
      // Return total number of permutations
      //------------------------------------

      BigInteger getTotal () {
        return total;
      }

      //-----------------------------
      // Are there more permutations?
      //-----------------------------

      boolean hasMore () {
        return numLeft.compareTo (BigInteger.ZERO) == 1;
      }

      //------------------
      // Compute factorial
      //------------------

      BigInteger getFactorial (int n) {
        BigInteger fact = BigInteger.ONE;
        for (int i = n; i > 1; i--) {
          fact = fact.multiply (new BigInteger (Integer.toString (i)));
        }
        return fact;
      }

      //--------------------------------------------------------
      // Generate next permutation (algorithm from Rosen p. 284)
      //--------------------------------------------------------

      int[] getNext () {

        if (numLeft.equals (total)) {
          numLeft = numLeft.subtract (BigInteger.ONE);
          return a;
        }

        int temp;

        // Find largest index j with a[j] < a[j+1]

        int j = a.length - 2;
        while (a[j] > a[j+1]) {
          j--;
        }

        // Find index k such that a[k] is smallest integer
        // greater than a[j] to the right of a[j]

        int k = a.length - 1;
        while (a[j] > a[k]) {
          k--;
        }

        // Interchange a[j] and a[k]

        temp = a[k];
        a[k] = a[j];
        a[j] = temp;

        // Put tail end of permutation after jth position in increasing order

        int r = a.length - 1;
        int s = j + 1;

        while (r > s) {
          temp = a[s];
          a[s] = a[r];
          a[r] = temp;
          r--;
          s++;
      }

        numLeft = numLeft.subtract (BigInteger.ONE);
        return a;
       
       }
   }

You might want to put the saveStrings() after the loop, not inside it. (all of this untested!)

[EDIT] In this case, the declaration of the StringBuffer should be before the loop, too.
And monkstone's remarks are spot on...

I corrected as you sugested. The problem is that it only writes the last permutation to the textfile, but in the text  area all the permutations are written...don't get it! Should I put a for loop somewhere? Or did I miss something?


PrintWriter output;
    int[] indices;
    String[] elements = {
      "1 ", "2 ", "3 ", "4 " 
    };
    PermutationGenerator x = new PermutationGenerator (elements.length);
    StringBuilder permutation;
   
    void setup() {
      while (x.hasMore()) {
         indices = x.getNext ();
                 permutation = new StringBuilder ();
 
        for (int i = 0; i < indices.length; i++) {
          permutation.append (elements[indices[i]]);
       }
        output = createWriter("permutations.txt");
        println (permutation.toString ());
   }
   }

void draw() {
  output. println(permutation.toString ());
  output.flush();
  output.close();
  exit();
}
 

Still untested, but this might work better:

1. void setup() {
2.   PrintWriter output = createWriter("permutations.txt");
3.   while (x.hasMore ()) {
4.     permutation = new StringBuilder();
5.     indices = x.getNext ();
6.     for (int i = 0; i < indices.length; i++) {
7.       permutation.append (elements[indices[i]]);
8.     }
9.     println (permutation.toString ());
10.     output.println(permutation.toString());
11.   }
12.   output.close();
13.   exit();
14. }

ALLELUJA it works! Aaah tank you so much PhiLho!
This forum is so great!!