diff and sortedby implemented

[helm.git] / helm / ocaml / mathql_interpreter / intersect.ml

diff --git a/helm/ocaml/mathql_interpreter/intersect.ml b/helm/ocaml/mathql_interpreter/intersect.ml
index 6bd620a108596575477b8c44cdf12cb426ed10d0..4152a280d926d3703d3d906cc29dc1bfc51d8e2f 100644 (file)
--- a/helm/ocaml/mathql_interpreter/intersect.ml
+++ b/helm/ocaml/mathql_interpreter/intersect.ml
@@ -55,13 +55,64 @@ let rec intersect_ex l1 l2 =
      {S.uri = uri2 ; S.attributes = attributes2}::tl2 ->
        try
         let attributes' = intersect_attributes (attributes1,attributes2) in
-         {S.uri = uri1 ; S.attributes = attributes'}::(intersect_ex tl1 tl2)
+         {S.uri = uri1 ; S.attributes = attributes' ; S.extra = ""}::(intersect_ex tl1 tl2)
        with
         NotCompatible ->
          intersect_ex tl1 tl2
 ;;
 
 let intersect_ex l1 l2 =
+ (* PRE-CLAUDIO
+ (*let _ = print_string ("INTERSECT ")
+ and t = Unix.time () in*)
+ let result = 
+  match (l1, l2) with
+     ((head1::tail1), (head2::tail2)) ->
+      (match (head1, head2) with
+          ([], _) -> assert false (* gli header non devono mai essere vuoti *)
+       |  (_, []) -> assert false (* devono contenere almeno [retVal] *)
+       |  (_,  _) ->
+           (match (tail1, tail2) with
+               ([], _) -> [["retVal"]] (* se una delle due code e' vuota... *)
+            |  (_, []) -> [["retVal"]] (* ... l'intersezione e' vuota *)
+            |  (_,  _) ->
+                [head2 @
+                 (List.find_all
+                 (function t -> not (List.mem t head2))
+                 head1
+                )
+               ] (* header del risultato finale *)
+               @
+               intersect_tails (List.tl head1) tail1 (List.tl head2) tail2
+               (*
+               List.fold_left
+                 (fun par1 elem1 -> par1 @
+                  List.map
+                  (fun elem2 ->
+                   [(List.hd elem1)] @
+                   (xres_join_context (List.tl head1) (List.tl elem1)
+                                      (List.tl head2) (List.tl elem2)
+                    )
+                  )
+                   (List.find_all (* *)
+                    (fun elem2 ->    (* trova tutti gli elementi della lista tail2 *)
+                    ((List.hd elem1) = (List.hd elem2)) && (* che stanno in tail1 *)
+                    not ((xres_join_context (List.tl head1) (List.tl elem1)
+                                            (List.tl head2) (List.tl elem2)) = [])
+                    (* e per i quali la xres_join_context non sia vuota *)
+                   )
+                    tail2 (* List.find_all *)
+                  )
+                  )
+                []
+                tail1 (* per ogni elemento di tail1 applica la List.fold_left *)
+               *)
+           ) (* match *)
+      )
+  | _ -> []
+   in
+    (*let _ = print_endline (string_of_float (Unix.time () -. t)); flush stdout in*)
+    result*)
  let before = Unix.time () in
  let res = intersect_ex l1 l2 in
  let after = Unix.time () in