1

"The Namespace or module 'Xxu' is not defined"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#light
open Xxu.Admissions.engine


(********************************************************************
 Set transcript data (should collect off of a form)
 ********************************************************************)
let tradtional = {is_full_yr=true; is_ap=false;is_honors=false;is_esl=false;is_prep=false;name=""}
let ap = {is_full_yr=true; is_ap=true;is_honors=false;is_esl=false;is_prep=false;name=""}
let honors = {is_full_yr=false; is_ap=false;is_honors=true;is_esl=false;is_prep=false;name=""}

let scores = [ {score=3.5; details=ap}; {score=3.2; details=honors}; {score=3.3;details=tradtional}]

print_float (calc_wieghted_gpa scores)
read_line()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#light
namespace Xxu.Admissions

module Engine =
   let ap_factor = 1.0
   let honors_factor = 0.5
   let default_factor = 0.0

   (********************************************************************
    class_details are shared across grading conventions 
  (letter, four point, five point, 100 point)
    ********************************************************************)
   type class_details= {
      name: string
      is_ap: bool 
      is_honors: bool
      is_esl: bool
      is_prep: bool   
      is_full_yr: bool 
   }

   type grade = {
      score: float
      details: class_details 
   }
   (********************************************************************
       active patterns to make rules for manipulating the scores easier
       to maintain.
    ********************************************************************)
   let predicate b = if b then Some() else None
   let (|IsAP|_|) d = predicate d.is_ap
   let (|IsHonors|_|) d = predicate d.is_honors
   let (|IsHalf|_|) d = predicate (d.is_full_yr = false)
   (********************************************************************
    general helpers
    ********************************************************************)
   let is_option (u) = (u = Some())
   let print_bool (b:bool) = print_string(b.ToString())
   let print_boolean = print_bool 
   (********************************************************************
    functions for scaling and computing GPA
    ********************************************************************)
   //Given the details of a class (or grade) what do I adjust the scale by
   let difficulty_factor d = 
      match d with
      | IsAP -> ap_factor
      | IsHonors -> honors_factor
      | _ -> default_factor

   // recurse over grades list and scale grades that need to be scaled
   let rec weigh_by_difficulty grades =
      let apply_weight g = 
         let factor = difficulty_factor g.details in
         // from what I am told they just add the factor to the GPA
         {score=(g.score + factor); details=g.details} in
       if grades = [] then []
       else apply_weight (List.hd grades) :: weigh_by_difficulty (List.tl grades)

   // recurse over grades list duplicate the grades that occur over a full yr, so they have more weight
   let rec weigh_by_duration grades =
      let duplicate_grade g = 
          // set up a class_details type as a copy of the incomming type, but switch term to 1/2
          let det = {is_full_yr=false; is_ap=g.details.is_ap;is_honors=g.details.is_honors;is_esl=g.details.is_esl;is_prep=g.details.is_prep;name=g.details.name} in
          // duplicate the grade and return a list
          [{score=g.score; details=det}; {score=g.score; details=det}] in
       let duplicate g = 
          match g.details with
          | IsHalf -> [g]
          | _ -> duplicate_grade g in
       if grades = [] then []
       else duplicate (List.hd grades) @ weigh_by_duration (List.tl grades)
    
   let weigh grades = weigh_by_duration (weigh_by_difficulty grades)
    
   let calc_gpa grades = 
      let rec sum grades = 
         if grades = [] then 0.0
         else (List.hd grades).score + sum(List.tl grades) in
       sum(grades) / (float (List.length grades))
    
   let calc_wieghted_gpa (grades:grade list) = calc_gpa (weigh grades)