source: experiments/frams/logic/data/scripts/abduction_misc.inc @ 884

//This file contains miscellaneous support functions for the abducibles generation experiment definition. 
//These include write-to-file function, a sorting algorithm and some combinatorial functions. 


function writeInfo(file_name,info)
{
  var f=File.appendDirect("" + file_name,"description");
  f.writeString(info);
  f.close();
}

function quickSort(listOfNumbers,sorted)
{
        var l=0,r=1;
        var stack = Vector.new();
        stack.add(listOfNumbers);
        while(stack.size > 0)
        {
                if(stack[0].size > 1)
                {
                        while(l < r)
                        {
                                l=1;
                                r = stack[0].size - 1;
                                for(l; l < stack[0].size - 1; l++)
                                        if(stack[0][0] <= stack[0][l])
                                                break;
                        
                        
                        
                                for(r; r > -1; r--)
                                        if(stack[0][0] > stack[0][r])
                                                break;
                                        
                                if(l < r)
                                {       
                                        var temp_l = stack[0][l];
                                        stack[0].set(l, stack[0][r]);
                                        stack[0].set(r, temp_l);                
                                }
                        
                                if(l == stack[0].size - 1)
                                {
                                        if(stack[0][0] > stack[0][l])
                                        {
                                                var temp_l = stack[0][0];
                                                stack[0].set(0, stack[0][l]);
                                                stack[0].set(l, temp_l);
                                        }
                                }
                        }
                        var left = Vector.new();
                        var right = Vector.new();
                        var i;
                
                        for(i = 0; i < l; i++)
                                left.add(stack[0][i]);
                        for(i = l; i < stack[0].size; i++)
                                right.add(stack[0][i]);
                
                        stack.remove(0);
                        listInsert(stack,left,0);
                        listInsert(stack,right,1);
                        l = 0;
                        r = stack[0].size;
                }
                else
                {
                        sorted.add(stack[0][0]);
                        stack.remove(0);
                }
        }
        
}

function generateBinaryCombinations(size)
{
        var stack = Vector.new();
        var i;
        
        stack.add(0);
        var counter = 0;
        var finish = -1;
        var combinations = Vector.new();
        while(stack.size > 0)
        {
                var z_counter = size - 1;
                if(stack.size < size)
                {
                        stack.add(0);
                        continue;
                }
                else
                {
                        if(stack.find(1) != -1)
                        {
                                counter++;
                                var temp_bin = Vector.new();
                                for(i = 0; i < stack.size; i++)
                                        temp_bin.add(stack[i]);
                                        
                                combinations.add(temp_bin);             
                        }
                }       
                
                if(stack.get(size - 1) == 0)
                {
                        stack.set(size - 1, 1);
                        continue;
                }
                        
                if(stack.get(size - 1) == 1)
                {
                        while(stack.get(z_counter) != 0 && z_counter > 0)
                                z_counter--;
                        
                        stack.set(z_counter, 1);
                        
                        while(z_counter != (stack.size - 1))
                                stack.remove(stack.size - 1);
                                
                        if(stack.get(0) == 1 && stack.size == 1)
                                
                                finish++;
                                
                                if(finish == 1)
                                        stack.clear();
                        
                }       
        }
        return combinations;
}