remove old @ignore decorator. closes #29

aeon/decorators/__init__.py

@@ -12,13 +12,12 @@ def fun(...) { ... }
 from aeon.decorators.api import DecoratorType
 from aeon.decorators.api import Metadata
 from aeon.sugar.program import Definition
-from aeon.synthesis_grammar.decorators import minimize_int, minimize_float, multi_minimize_float, ignore, syn_ignore
+from aeon.synthesis_grammar.decorators import minimize_int, minimize_float, multi_minimize_float, syn_ignore
 
 decorators_environment: dict[str, DecoratorType] = {
     "minimize_int": minimize_int,
     "minimize_float": minimize_float,
     "multi_minimize_float": multi_minimize_float,
-    "ignore": ignore,
     "syn_ignore": syn_ignore,
 }
 

aeon/synthesis_grammar/decorators.py

@@ -1,6 +1,5 @@
 """Meta-programming code for optimization-related decorators."""
 
-import aeon.synthesis_grammar.grammar as grammar
 from aeon.core.terms import Term, Var
 from aeon.core.types import BaseType
 from aeon.decorators.api import Metadata
@@ -64,19 +63,6 @@ def multi_minimize_float(
     return fun, [fitness_function], metadata
 
 
-def ignore(args: list[Term], fun: Definition, metadata: Metadata) -> tuple[Definition, list[Definition], Metadata]:
-    # @grammar_skip
-    """This decorator expects a zero argument .
-
-    It does not modify the original definition. It makes sure that no
-    grammar node is generated from this function.
-    """
-    assert len(args) == 0
-    grammar.internal_functions.append(fun.name)
-    # internal_function = Definition(name=internal_name_for(fun.name), args=fun.args, type=fun.type, body=fun.body)
-    return fun, [], metadata
-
-
 def syn_ignore(args: list[Term], fun: Definition, metadata: Metadata) -> tuple[Definition, list[Definition], Metadata]:
     """This decorator expects a zero argument .
 

examples/PSB2/annotations/fizz_buzz_annotations.ae

@@ -1,9 +1,3 @@
-# Given an integer n, return "Fizz" if n is divisible by 3,
-# "Buzz" if n is divisible by 5, "FizzBuzz" if n is
-# divisible by 3 and 5, and a string version of n if none of
-# the above hold (convert integer to string).
-# input : integer in [1, 1000000]
-# output : string
 # --not working properly--
 import PSB2;
 
@@ -22,13 +16,10 @@ def FizzBuzz ( n :{x:Int | 1 <= x && x <= 1000000}) : String {
     if div15 n then "FizzBuzz" else (if ((n % 3) == 0) then "Fizz" else (if ((n % 5) == 0)  then "Buzz" else native "str(n)"))
 }
 
-@ignore()
 def  train: TrainData =  extract_train_data ( load_dataset "fizz-buzz" 200 200);
 
-@ignore()
 def  input_list : List =  get_input_list ( unpack_train_data  train);
 
-@ignore()
 def  expected_values : List =  get_output_list ( unpack_train_data  train);
 
 @minimize_float(String_distance ( join_string_list( get_fb_synth_values input_list synth)) ( join_string_list( expected_values)))

examples/PSB2/annotations/middle_char_annotations.ae

@@ -2,20 +2,6 @@ import String;
 import Math;
 import PSB2;
 
-def middle_char  (s: String) : String {
-    str_len:Int = String_len s;
-    if ((str_len % 2) == 0) then
-        #snd_mid_char_index: Int = str_len / 2;
-        snd_mid_char_index: Int = Math_floor(Math_toFloat(str_len) /. 2.0)+1;
-        fst_mid_char_index: Int = snd_mid_char_index - 2 ;
-        mid_chars = String_slice s fst_mid_char_index snd_mid_char_index;
-        mid_chars
-    else
-        mid_char_index: Int = Math_floor(Math_toFloat(str_len) /. 2.0);
-        m_char = String_slice s mid_char_index (mid_char_index+1);
-        m_char
-
-}
 
 def  train: TrainData =  extract_train_data ( load_dataset "middle-character" 200 200);
 def  input_list : List =  get_input_list ( unpack_train_data  train);

examples/PSB2/annotations/multi_objective/dice_game.ae

@@ -1,17 +1,28 @@
 import Math;
-import PSB2;
+import extract_train_data from PSB2;
+import get_input_list from PSB2;
+import get_output_list from PSB2;
+import calculate_list_errors from PSB2;
+import get_dg_synth_values from PSB2;
+import unpack_train_data from PSB2;
+import load_dataset from PSB2;
+
 
-@ignore()
 def train: TrainData = extract_train_data (load_dataset "dice-game" 200 200);
 
-@ignore()
 def input_list : List = get_input_list (unpack_train_data train);
 
-@ignore()
 def expected_values : List = get_output_list (unpack_train_data train);
 
+@syn_ignore(extract_train_data,
+            get_input_list,
+            get_output_list,
+            unpack_train_data,
+            load_dataset,
+            get_dg_synth_values,
+            calculate_list_errors)
 @multi_minimize_float(calculate_list_errors  (get_dg_synth_values input_list synth)(expected_values))
-def synth ( n : {a:Int | 1 <= a && a <= 10000} , m : {b:Int | 1 <= b && b <= 10000}) : Float
+def synth (n: Int, m: Int) : Float
     {
         (?hole:Float)
     }

examples/PSB2/annotations/multi_objective/gcd.ae

@@ -1,17 +1,22 @@
-# Given two integers, return the largest integer that
-# divides each of the integers evenly.
-# input : 2 integers in [1, 1000000]
-# output : integer
-import PSB2;
-
-def gcd ( n:Int, z:Int) : Int {
-    if z == 0 then n else (gcd(z)(n % z))
-}
+import extract_train_data from PSB2;
+import get_input_list from PSB2;
+import get_output_list from PSB2;
+import calculate_list_errors from PSB2;
+import get_gcd_synth_values from PSB2;
+import unpack_train_data from PSB2;
+import load_dataset from PSB2;
 
 def train: TrainData = extract_train_data (load_dataset "gcd" 200 200);
 def input_list : List = get_input_list (unpack_train_data train);
 def expected_values : List = get_output_list (unpack_train_data train);
 
+@syn_ignore(extract_train_data,
+            get_input_list,
+            get_output_list,
+            unpack_train_data,
+            load_dataset,
+            get_gcd_synth_values,
+            calculate_list_errors)
 @multi_minimize_float( calculate_list_errors (get_gcd_synth_values input_list synth) (expected_values))
 def synth ( n:Int, z:Int) : Int {
     (?hole:Int)

examples/PSB2/annotations/multi_objective/snow_day.ae

@@ -1,32 +1,23 @@
-# Snow Day (HW) : Given an integer representing a number
-# of hours and 3 floats representing how much snow is on the
-# ground, the rate of snow fall, and the proportion of snow
-# melting per hour, return the amount of snow on the ground
-# after the amount of hours given. Each hour is considered a
-# discrete event of adding snow and then melting, not a continuous process.
-# input : integer in [0, 20], float in [0.0, 20.0], float in [0.0, 10.0], float in [0.0, 1.0]
-# output : float
 import Math;
-import PSB2;
-
-#def snow_day ( n : {x:Int | 0 <= x && x <= 20} ,
-#                m : {y:Float | 0.0 <= y && y <= 20.0},
-#                t : {z:Float | 0.0 <= z && z <= 10.0},
-#                p : {w:Float | 0.0 <= w && w <= 10.0}) : Float {
-#    if n == 0 then m else snow_day (n - 1) ((1.0 -. p) *. (m +. t)) (t) (p)
-#}
-
-#def snow_day ( n :Int  ,
-#                m :Float ,
-#                t :Float ,
-#                p :Float) : Float {
-#    if n == 0 then m else snow_day (n - 1) ((1.0 -. p) *. (m +. t)) (t) (p)
-#}
+import extract_train_data from PSB2;
+import get_input_list from PSB2;
+import get_output_list from PSB2;
+import calculate_list_errors from PSB2;
+import get_snowd_synth_values from PSB2;
+import unpack_train_data from PSB2;
+import load_dataset from PSB2;
 
 def train: TrainData = extract_train_data (load_dataset "snow-day" 200 200);
 def input_list : List = get_input_list (unpack_train_data train);
 def expected_values : List = get_output_list (unpack_train_data train);
 
+@syn_ignore(extract_train_data,
+            get_input_list,
+            get_output_list,
+            unpack_train_data,
+            load_dataset,
+            get_snowd_synth_values,
+            calculate_list_errors)
 @multi_minimize_float( calculate_list_errors (get_snowd_synth_values input_list synth) (expected_values))
 def synth ( n :Int  ,
                 m :Float ,

examples/PSB2/annotations/multi_objective/square_digits.ae

@@ -1,34 +1,24 @@
-# Given a positive integer, square each digit and
-# concatenate the squares into a returned string.
-# input : integer in [0, 1000000]
-# output : string
 import String;
 import Math;
-import PSB2;
-
-#def square_digit  ( n :{x:Int | 0 <= x && x <= 1000000}) : String {
-#    if n == 0 then
-#        ""
-#    else
-#        digit = n % 10;
-#        square = digit * digit;
-#        result = String_concat (square_digit(Math_floor_division n 10)) (String_intToString(square));
-#        result
-#}
-
-def square_digit_unsafe  ( n : Int) : String {
-    if n == 0 then
-        ""
-    else
-        digit = n % 10;
-        square = digit * digit;
-        result = String_concat (square_digit_unsafe(Math_floor_division n 10)) (String_intToString(square));
-        result
-}
+import extract_train_data from PSB2;
+import get_input_list from PSB2;
+import get_output_list from PSB2;
+import calculate_list_errors from PSB2;
+import get_sd_synth_values from PSB2;
+import unpack_train_data from PSB2;
+import load_dataset from PSB2;
+import calculate_str_list_errors from PSB2;
 
 def train: TrainData = extract_train_data (load_dataset "square-digits" 200 200);
 def input_list : List = get_input_list (unpack_train_data train);
 def expected_values : List = get_output_list (unpack_train_data train);
 
+@syn_ignore(extract_train_data,
+            get_input_list,
+            get_output_list,
+            unpack_train_data,
+            load_dataset,
+            get_sd_synth_values,
+            calculate_list_errors)
 @multi_minimize_float(calculate_str_list_errors (get_sd_synth_values input_list synth) (expected_values))
 def synth ( n : Int) : String {(?hole:String)}

examples/PSB2/annotations/single_objective/bouncing_balls.ae

@@ -1,18 +1,27 @@
-# currently this is not working
 import Math;
-import PSB2;
+import extract_train_data from PSB2;
+import get_input_list from PSB2;
+import get_output_list from PSB2;
+import calculate_list_errors from PSB2;
+import get_bb_synth_values from PSB2;
+import unpack_train_data from PSB2;
+import load_dataset from PSB2;
+import mean_absolute_error from PSB2;
 
-type Unit;
 
-@ignore()
 def train: TrainData =  extract_train_data ( load_dataset "bouncing-balls" 200 200);
 
-@ignore()
 def  input_list : List =  get_input_list ( unpack_train_data train);
 
-@ignore()
 def  expected_values : List =  get_output_list ( unpack_train_data train);
 
+@syn_ignore(extract_train_data,
+            get_input_list,
+            get_output_list,
+            unpack_train_data,
+            load_dataset,
+            get_bb_synth_values,
+            calculate_list_errors)
 @minimize_float(  mean_absolute_error ( get_bb_synth_values  input_list synth) ( expected_values))
 def synth (a:Float , b:Float , c:Int) : Float
     {

examples/PSB2/annotations/single_objective/dice_game.ae

@@ -1,23 +1,28 @@
 import Math;
-import PSB2;
-#def mult ( n:Int , m:Int ) : Int { n * m }
+import extract_train_data from PSB2;
+import get_input_list from PSB2;
+import get_output_list from PSB2;
+import calculate_list_errors from PSB2;
+import get_dg_synth_values from PSB2;
+import unpack_train_data from PSB2;
+import load_dataset from PSB2;
+import mean_absolute_error from PSB2;
 
-#def peter_wins: ( n:Int ) -> ( m:Int ) -> Int = \n -> \m-> if m == 0 then 0 else (Math_max 0 (n - m)) + peter_wins n (m - 1);
-
-#def dice_game ( n : {x:Int | 1 <= x && x <= 10000} , m : {y:Int | 1 <= y && y <= 10000}) : Float {
-#    Math_toFloat(peter_wins n  m ) /. Math_toFloat(mult n m)  }
-
-@ignore()
 def  train: TrainData =  extract_train_data ( load_dataset "dice-game" 200 200);
 
-@ignore()
 def  input_list : List =  get_input_list ( unpack_train_data  train);
 
-@ignore()
 def  expected_values : List =  get_output_list ( unpack_train_data  train);
 
+@syn_ignore(extract_train_data,
+            get_input_list,
+            get_output_list,
+            unpack_train_data,
+            load_dataset,
+            get_dg_synth_values,
+            calculate_list_errors)
 @minimize_float(mean_absolute_error  (get_dg_synth_values input_list synth)(expected_values))
-def synth ( n : {a:Int | 1 <= a && a <= 10000} , m : {b:Int | 1 <= b && b <= 10000}) : Float
+def synth (n: Int , m: Int) : Float
     {
         (?hole:Float)
     }

examples/PSB2/annotations/single_objective/gcd.ae

@@ -1,8 +1,13 @@
-# Given two integers, return the largest integer that
-# divides each of the integers evenly.
-# input : 2 integers in [1, 1000000]
-# output : integer
-import PSB2;
+
+import extract_train_data from PSB2;
+import get_input_list from PSB2;
+import get_output_list from PSB2;
+import calculate_list_errors from PSB2;
+import get_gcd_synth_values from PSB2;
+import unpack_train_data from PSB2;
+import load_dataset from PSB2;
+import mean_absolute_error from PSB2;
+
 
 def gcd ( n:Int, z:Int) : Int {
     if z == 0 then n else (gcd(z)(n % z))
@@ -12,8 +17,15 @@ def  train: TrainData =  extract_train_data ( load_dataset "gcd" 200 200);
 def  input_list : List =  get_input_list ( unpack_train_data  train);
 def  expected_values : List =  get_output_list ( unpack_train_data  train);
 
+
+@syn_ignore(extract_train_data,
+            get_input_list,
+            get_output_list,
+            unpack_train_data,
+            load_dataset,
+            get_gcd_synth_values,
+            calculate_list_errors)
 @minimize_float(  mean_absolute_error ( get_gcd_synth_values  input_list synth) ( expected_values))
 def synth ( n:Int, z:Int) : Int {
     (?hole:Int)
 }
-# def largest_common_divisor ( n :{x:Int | 1 <= x && x <= 1000000},  m :{y:Int | 1 <= y && y <= 1000000}) : Int { gcd n m }