Saaksjaerven Loiske contra Haka Juniorit

Overview de la Competencia: Saaksjaerven Loiske vs Haka Juniorit

El enfrentamiento entre Saaksjaerven Loiske y Haka Juniorit promete ser un evento futbolístico emocionante que capturará la atención de los aficionados y apostadores. Actualmente, el foco está en hacer predicciones precisas basadas en estadísticas y tendencias históricas. Ambos equipos han mostrado un rendimiento equilibrado, lo que sugiere un partido lleno de oportunidades de apuestas intrigantes. A continuación, se desglosan diferentes opciones de apuestas, considerando las tendencias más recientes y el historial de los equipos.

Predictions Comparadas

Apuesta: Ambos Equipos No Anotarán en El Primer Tiempo

Probabilidad: 98.30%

Con ambas defensivas mostrando consistentemente sólida resistencia durante los primeros 45 minutos, esta apuesta es altamente sugerible. Saaksjaerven Loiske y Haka Juniorit han mantenido un enfoque conservador, especialmente al comienzo de los partidos, lo que respalda esta alta probabilidad.

Apuesta: Ambos Equipos No Anotarán en El Segundo Tiempo

Probabilidad: 97.70%

Esta apuesta tiene una probabilidad similar a la del primer tiempo. Los datos muestran que ambos equipos tienden a afinar su táctica defensiva conforme avanza el encuentro, reservando sus fuerzas para un impacto más estratégico en el segundo tiempo.

Apuesta: Más De 1.5 Goles (Over 1.5 Goals)

Probabilidad: 73.30%

Dada la puntuación alta promedio de goles y el enfoque ofensivo que ambos equipos han adoptado cuando se encuentran fuera de su terreno, apostar por que se anotará más de 1.5 goles parece razonable. Las tácticas agresivas aseguran una apertura de espacio y mayores oportunidades de gol a mitad de partido.

Apuesta: Ambos Equipos Marcarán (Both Teams To Score)

Probabilidad: 63.00%

Con un promedio combinado de más de cinco goles por partido para ambos equipos, es razonable esperar que cada lado consiga marcar. Historias de enfrentamientos pasados confirman que ambos equipos tienen fortalezas ofensivas notables que probablemente resultarán en goles para cada uno.

Apuesta: Más De 2.5 Goles (Over 2.5 Goals)

Probabilidad: 61.00%

Dada la naturaleza abierta del partido y el promedio total de goles elevado, apostar por que se anotarán más de 2.5 goles es una opción plausible. Esto sugiere un partido emocionante lleno de acciones dinámicas, enfocado en la ofensiva.

Apuesta: Victoria del Equipo Visitante (Away Team To Win)

Probabilidad: 60.40%

Con Saaksjaerven Loiske jugando fuera de casa, su táctica de presionar constantemente a su adversario para desorganizar la estructura defensiva podría darles una ventaja. Las estadísticas indican que el equipo visitante suele tener un índice de victorias más alto en esta competición.

Conclusiones Estadísticas

El promedio total de goles para este partido se ha calculado en 5.16, con Saaksjaerven Loiske y Haka Juniorit promediando 2.89 y 2.97 goles respectivamente como anfitriones y visitantes. Estas cifras resaltan un duelo que, sin lugar a dudas, será rico en goles y emociones hasta el último silbato.

Knawd/COMP90023-para/README.md
# COMP90023-para
Programming Language Semantics
Knawd/COMP90023-para/assignment-2/eval.ml
open Syntax

module M = Map.Make(struct type t = loc let compare = compare end)

type mem = (loc * literal) M.t

let lookup env id =
try Some (List.assoc id env)
with Not_found -> None

let rec sym_lookup env id =
match env with
| [] -> None
| (x,t)::rs when x = id -> Some t
| _::rs -> sym_lookup rs id

type heap = { blocks : (blkid*blk) M.t; next_blkid : int }
type parseState = { env : (id * typ) list; heap : heap }

(* TODO: add type checking here *)
let typecheck e ps =
let rec mkerror loc msg =
Error (loc, msg) in
let rec type_error exp msg =
Error ((exp.pos, exp.pos), «Type error in expression: «^msg)
in
let exp_type e =
match e with
| E_unit _ -> T_unit
| E_bool _ -> T_bool
| E_int _ -> T_int
| E_id _ ->
(try T_any with Not_found -> mkerror e.pos «Undefined identifier»)
| E_app(_,(fst::rst,_)) ->
let ft = exp_type fst in
let rst’ = List.map (fun (_,s) -> snd (exp_type s)) rst in
(match ft with
| TFun (args,res) when args = rst’ -> res
| _ -> type_error e «Illegal function application»)
| E_proj(_,(e1,i),j) ->
let te1 = exp_type e1 in
(match te1 with
| T_pair(t1,t2) when (i=j) && (i=1 || i=2) -> snd_list i te1
| _ -> type_error e «Illegal projection»)
| E_pair(_,(s1,s2)) -> T_pair (exp_type s1, exp_type s2)
| E_inj(_,(i,e)) ->
(match exp_type e with
| T_pair(t1,t2) when (i=1 || i=2) -> snd_list i (T_pair(t1,t2))
| _ -> type_error e «Illegal injection»)
| E_alloc(_,e) -> T_any
| E_case _ ->
(failwith «Should not typecheck E_case»)
in

let exp_rval e =
match e with
| E_unit _ -> Err()
| E_bool b -> Ok b
| E_int i -> Ok i
| E_id id ->
(try Ok (var_val (List.assoc id ps.env))
with Not_found -> mkerror e.pos («Undefined identifier: «^id))
| E_app (_, _) ->
mkerror e.pos «Typechecking a thunk expression»
| E_proj _ ->
mkerror e.pos «Typechecking a thunk expression»
| E_pair(_,_) ->
mkerror e.pos «Typechecking a thunk expression»
| E_inj _ ->
mkerror e.pos «Typechecking a thunk expression»
| E_alloc _ ->
mkerror e.pos «Typechecking a thunk expression»
| E_case (_,_,_,_) ->
mkerror e.pos «Typechecking a thunk expression»
in

let rec exp_val ty e =
match e with
| E_unit li -> Ok (V_unit li, ty)
| E_bool(b, li) -> Ok (V_bool(b,li),ty)
| E_int(i,li) -> Ok (V_int(i,li),ty)
| E_id(id,li) ->
let v = var_val (List.assoc id ps.env) in
Ok(v, snd v)
| E_app(e1,(args,[rattr]),li) ->
begin match exp_val T_any e1 with
| Ok (v1,badty) ->
(match v1 with
| V_thunk(e1′,ty1) when ty1 = TFun(args,badty) ->
exp_val badty e1′
| V_unit _ ->
TypeError(li, «Cannot apply unit»)
| V_literal _ ->
TypeError(li, «Cannot apply a literal»)
| V_closure(params,(l,blk’),env’) when l == li ->
if args = params then
match exp_val badty rattr with
| Ok(v,badty’) ->
Ok(V_closure([badty’],(l,blk’),env’), badty)
| Error(msg) -> Error(msg)
else Error(«Typechecking E_app: argument lists do not match»)
| V_closure _ ->
TypeError((l,e1.pos), «Cannot close over an existing closure.»)
| V_locloc((l1,l2),_) ->
TypeError((l,e1.pos), «Cannot apply locations.»)
| V_pair _ ->
TypeError((l,e1.pos), «Cannot apply a pair.»)
)
| Error(msg) -> Error(msg)
end
| E_proj(_,_) ->
mkerror e.pos «Typechecking a thunk expression»
| E_inj(_,_) ->
mkerror e.pos «Typechecking a thunk expression»
| E_pair(_,_) ->
mkerror e.pos «Typechecking a thunk expression»
| E_alloc(_,_) ->
mkerror e.pos «Typechecking a thunk expression»
| E_case _ ->
mkerror e.pos «Typechecking a thunk expression»

and assign mem loc lval =
let loc_sym = loc_symbol loc in (* TODO: use the right thing *)
match lval with
L_value(v) ->
match v with
| V_unit(l) -> mem
| V_bool(b,l) -> mem
| V_int(i,l) -> mem
| V_alloc(loc,l)
| V_literal(l,_)
| V_locloc((l’,l),_) ->
M.add loc_symbol lval mem
(* TODO: implement closure case *)
(* TODO: implement pair case *)
(* Let’s just crash for now… *)
(* TODO: implement case for memory locations *)
(* TODO: implement block case *)
| _ -> failwith «assignment»

L_deref((blk_label,lbl),locs) ->
if locs = [] then
M.add loc_sym ((V_alloc(loc,lbl), T_any)) mem
else
(* I’ve never actually seen this case in an example before *)
failwith «Deref with location list»
L_proj(fst,(i,lbl),locs) ->
failwith «proj field»
L_inj(i,(e,lbl),locs) ->
failwith «inj field»
L_case((types,cases),(c_t,cases’),loc,locs) ->
failwith «case field»

and var_val v =
match v with
V_value(v) ->
v

V_deref((blk_label,lbl),slots) ->
let h = ps.heap in
try
let b = M.find blk_label h.blocks in
snd (List.nth b.slots(lbl)) (* TODO: use the right thing *)
with
Not_found -> failwith «Deref of undefined block» |
Invalid_argument(«nth») ->
failwith («Attempted to dereference block label «^lbl^» that is undefined in block «^blk_label)

V_proj(fst,(i,lbl),slots) ->
let h = ps.heap in
try
let b = M.find fst.blocks h.blocks in
let loc = snd(List.nth b.slots(lbl)) in
proj i loc slots
with
Not_found -> failwith «Proj of undefined block» |
Invalid_argument(«nth») ->
failwith («Attempted to dereference block label «^lbl^» that is undefined in block «^fst.blocks)

V_inj(i,(e,lbl),slots) ->
failwith «inj field»
V_case((types,cases),(c_t,cases’),blocks,locs) ->
failwith «case field»

V_caseref((cases,cs),(a,lbl),slots) ->
let lval = cs.(a) in
let updated_slots =
Array.init slots.length (fun i -> if i = lbl then lval else cs.(i))
in
V_case((types,cases),(c_t,updated_slots),blocks,locs)

V_closure((params,(l,blk)),env’) ->
((params,(l,blk)),env’)

and proj i loc slots =
let h = ps.heap in
try let b = M.find loc.blocks h.blocks in
let loc’ = snd(List.nth b.slots(loc.label)) in
proj i loc’ slots
with
Not_found -> failwith «Proj of undefined block» |
Invalid_argument(«nth») ->
failwith («Attempted to dereference block label «^loc.label^» that is undefined in block «^loc.blocks)

and update_blk ps loc slot val’ slots =
let h’ = { ps.heap with blocks = M.add loc.blocks ({slots = slots},blkid_of_int loc.label) ps.heap.blocks} in
{ ps with heap = h’ }

and update_heap h blk l lbl lv slots =
let h’ = { h with blocks = M.add blk.blocks ({slots = slots},blkid_of_int blk.label) h.blocks} in
{ h with heap = h’ }

and update_heap’ ({heap=h} as ps) blk lv slots =
update_heap h blk blk.label lv slots

and update_slot loc sym i slots =
if i = slots.length then
if sym freshloc_symbol() then failwith («Updating unmatched symbol «^sym)
else slots
else
let l’ = slots.(i) in
if l’.label sym then failwith («Updating unmatched symbol «^sym)
else Array.set slots i lv; slots

and update_slots loc root lv slots =
if loc.label root then failwith («Locating at root different from loc label»)
else update_slot loc.symbol root slots.Length slots

and update_slots’ ({env=e} as ps) loc root lv slots =
update_slots loc root lv slots

and fresh_loc h =
{symbol=freshloc_symbol(); label=ps.heap.next_blkid; blocks=Int32.to_string h.next_blkid};
{ps with heap={h with next_blkid=h.next_blkid+1}}

and lookup_blk ({heap=h} as ps) blk lbl =
let b’ = M.find blk h.blocks in
if b’.label lbl then failwith «Looking up wrong block label»
else b’

and binding_env env id typ =
env@[id,typ]

and subst_rec_calls ps e =
match e with
E_rec(id,args,body,lbl) when is_anybody_in_list id args -> Failwith «recursive function can’t be called itself.»
(* TODO: some recursive functions could be given full types after binding *)
(* else *)
(* TODO: find out whether there exists any recursive function bound to v *)
(* TODO: if there is one, substitute that bound non-var v for *)

and subst_cps ps expr =
let vars = ref [] in
let expr’ =
subst_rec_calls ps expr;
subst_helper vars expr
in (* TODO: bind all variables besides id to Any_t? *)
{env=List.map(fun (x,t)->x,T_any) ps.env;heap=ps.heap},expr’

and subst_helper vars x =
(* TODO: check if ever call a non-freshly introduced function in cps mode *)
match x with
(* TODO: handle recursive call *)
(* if recursive call change the environment *)
(* otherwise same as usual cases below *)
(* TODO: exactly how do we handle recursive functions? *)
(* TODO: or do we simply say that CPS cannot handle recursive functions? *)

(* TODO: just remove the CPS handler from here so that CPS works at all: *)
(* E_app(l,(fst::rst,snd),END) when is_binding (L_cps(apply_at)) l -> *)
(* failwith («CPS handler called: «^string_of_exp l^» at «^string_of_loc END); *)

| _ ->
subst_evars vars x

and subst_evars vars x =
Expr.subst x (fun l -> List.assoc l.vars vars)

in
let pss’ = subst_cps ps in

let rhs_type = exp_type e.rhs in

let assign_type tty ty =
match tty with
T_any -> match ty with (* TODO: how should we handle this case? *)
| T_any -> lhs_type t_t
| _ -> failwith («lhs_type «^string_of_typ t_t^» does not match assignment value type «^string_of_typ ty)

| T_unit when ty = T_unit -> T_unit
| T_bool when ty = T_bool -> T_bool
| T_int when ty = T_int -> T_int
| TFun(args,badty) when args=[] && badty=ty && ty=T_any -> badty