Testing padding functionality:

Padded array (dims 4x6, unpadded region 2x3):

-999.0 -999.0 -999.0 -999.0 -999.0 -999.0

-999.0 -999.0 1.0 2.0 3.0 -999.0

-999.0 -999.0 4.0 5.0 6.0 -999.0

-999.0 -999.0 -999.0 -999.0 -999.0 -999.0

Expected: padding value (-999.0) in margins, data values (1.0-6.0) in center region

type print_style = Only_labels | Axis_size | Axis_number_and_size | Projection_and_size

[@@deriving equal, compare, sexp]

match style with

| Only_labels -> ( match label with None -> "_" | Some l -> l)

| Axis_size | Axis_number_and_size ->

let label_prefix = match label with None -> "" | Some l -> l ^ "=" in

(match (proj_id, padding) with

| None, None -> label_prefix ^ Int.to_string d

| None, Some p -> label_prefix ^ [%string "%{d#Int}+%{p#Int}"]

| Some _, None -> label_prefix ^ Int.to_string d

| Some _, Some p -> label_prefix ^ [%string "%{d#Int}+%{p#Int}"])

| Projection_and_size ->

let label_part = match label with None -> "" | Some l -> l ^ "=" in

let size_part = Int.to_string d in

let padding_part = match padding with None -> "" | Some p -> "+" ^ Int.to_string p in

let proj_part = match proj_id with None -> "" | Some pid -> "p" ^ Proj_id.to_string pid in

let extra_parts =

match (proj_id, padding) with

| None, None -> ""

| None, Some _ -> padding_part

| Some _, None -> "[" ^ proj_part ^ "]"

| Some _, Some _ -> "[" ^ proj_part ^ "]" ^ padding_part

in

label_part ^ size_part ^ extra_parts

| Dim { label = None; _ } when equal_print_style style Only_labels -> "_"

| Dim { label = Some l; _ } when equal_print_style style Only_labels -> l

| Dim { d; label = None; padding = None; proj_id = None } when equal_print_style style Axis_size -> Int.to_string d

| Dim { d; label = Some l; padding = None; proj_id = None } when equal_print_style style Axis_size -> [%string "%{l}=%{d#Int}"]

| Dim { d; label = None; padding = Some p; proj_id = None } when equal_print_style style Axis_size -> [%string "%{d#Int}+%{p#Int}"]

| Dim { d; label = Some l; padding = Some p; proj_id = None } when equal_print_style style Axis_size -> [%string "%{l}=%{d#Int}+%{p#Int}"]

| Dim solved_dim -> solved_dim_to_string style solved_dim

let label_part = match v.label with None -> "" | Some l -> ":" ^ l in

if coeff = 1 then [%string "$%{v.id#Int}%{label_part}"] else [%string "%{coeff#Int}*$%{v.id#Int}%{label_part}"])

type print_style = Only_labels | Axis_size | Axis_number_and_size | Projection_and_size

[@@deriving equal, compare, sexp]

val solved_dim_to_string : print_style -> solved_dim -> string

val dim_to_string : print_style -> dim -> string

let to_string_hum ?(style = Row.Axis_size) (sh : t) =

| Row.Only_labels | Axis_size | Projection_and_size -> Row.dim_to_string style d

| Axis_number_and_size -> Int.to_string num ^ ":" ^ Row.dim_to_string style d)

?style:Row.print_style ->

^ Shape.to_string_hum ~style:Row.Axis_number_and_size sh

let axes_spec = if needs_spec then Some (Shape.to_string_hum ~style:Row.Only_labels sh) else None in

(executable

(name test_print_style)

(modules test_print_style)

(libraries ocannl)

(preprocess

(pps ppx_ocannl)))

(rule

(target test_print_style.output)

(deps test_print_style.exe ocannl_config)

(action

(with-stdout-to

%{target}

(run %{deps}))))

(rule

(alias runtest)

(action

(diff test_print_style.expected test_print_style.output)))

Welcome to OCANNL! Reading configuration defaults from /Users/lukstafi/ocannl/_build/default/test/ocannl_config.

Retrieving commandline, environment, or config file variable ocannl_log_level

Found 0, in the config file

Testing print_style functionality:

=== Testing solved_dim_to_string ===

Full attributes (d=28, padding=2, label=height, proj_id):

Only_labels: height

Axis_size: height=28+2

Axis_number_and_size: height=28+2

Projection_and_size: height=28+2

Minimal attributes (d=64, no padding, no label, no proj_id):

Only_labels: _

Axis_size: 64

Projection_and_size: 64

With padding only (d=32, padding=3, label=width, no proj_id):

Axis_size: width=32+3

Projection_and_size: width=32+3

With projection (d=32, label=width, proj_id):

Axis_size: width=32

Projection_and_size: width=32[p1]

=== Testing dim_to_string ===

Solved dimensions:

Only_labels (full): height

Axis_size (full): height=28+2

Projection_and_size (full): height=28+2

Only_labels (minimal): _

Axis_size (minimal): 64

Variable dimensions:

Only_labels (labeled var): $1:channels

Axis_size (labeled var): $1:channels

Projection_and_size (labeled var): $1:channels

Only_labels (unlabeled var): $2

Axis_size (unlabeled var): $2

=== Testing Shape.to_string_hum ===

Shape with batch=[1], input=[784], output=[10,5]:

Only_labels: _|_->_,_

Axis_size: 1|784->10,5

Axis_number_and_size: 0:1|3:784->1:10,2:5

Projection_and_size: 1|784->10,5

Default style: 1|784->10,5

let test_print_styles () =

let open Ocannl.Row in

Stdio.printf "Testing print_style functionality:\n\n";

(* Create a solved dimension with all possible attributes *)

let solved_dim_full = {

d = 28;

padding = Some 2;

label = Some "height";

proj_id = None

} in

(* Create a dimension with projection by using fresh_row_proj *)

let row_with_dim = {

dims = [get_dim ~d:32 ~label:"width" ()];

bcast = Broadcastable;

id = row_id ~sh_id:1 ~kind:`Output

} in

let row_with_proj = fresh_row_proj row_with_dim in

let solved_dim_with_proj = match row_with_proj.dims with

| [Dim sd] -> sd

| _ -> failwith "Expected single dimension"

in

(* Create a solved dimension with minimal attributes *)

let solved_dim_minimal = {

d = 64;

padding = None;

label = None;

proj_id = None

} in

(* Create a solved dimension with only padding *)

let solved_dim_padding = {

d = 32;

padding = Some 3;

label = Some "width";

proj_id = None

} in

(* Create a variable dimension *)

let var_dim_labeled = get_var ~label:"channels" () in

let var_dim_unlabeled = get_var () in

Stdio.printf "=== Testing solved_dim_to_string ===\n";

Stdio.printf "Full attributes (d=28, padding=2, label=height, proj_id):\n";

Stdio.printf " Only_labels: %s\n" (solved_dim_to_string Only_labels solved_dim_full);

Stdio.printf " Axis_size: %s\n" (solved_dim_to_string Axis_size solved_dim_full);

Stdio.printf " Axis_number_and_size: %s\n" (solved_dim_to_string Axis_number_and_size solved_dim_full);

Stdio.printf " Projection_and_size: %s\n" (solved_dim_to_string Projection_and_size solved_dim_full);

Stdio.printf "\nMinimal attributes (d=64, no padding, no label, no proj_id):\n";

Stdio.printf " Only_labels: %s\n" (solved_dim_to_string Only_labels solved_dim_minimal);

Stdio.printf " Axis_size: %s\n" (solved_dim_to_string Axis_size solved_dim_minimal);

Stdio.printf " Projection_and_size: %s\n" (solved_dim_to_string Projection_and_size solved_dim_minimal);

Stdio.printf "\nWith padding only (d=32, padding=3, label=width, no proj_id):\n";

Stdio.printf " Axis_size: %s\n" (solved_dim_to_string Axis_size solved_dim_padding);

Stdio.printf " Projection_and_size: %s\n" (solved_dim_to_string Projection_and_size solved_dim_padding);

Stdio.printf "\nWith projection (d=32, label=width, proj_id):\n";

Stdio.printf " Axis_size: %s\n" (solved_dim_to_string Axis_size solved_dim_with_proj);

Stdio.printf " Projection_and_size: %s\n" (solved_dim_to_string Projection_and_size solved_dim_with_proj);

Stdio.printf "\n=== Testing dim_to_string ===\n";

Stdio.printf "Solved dimensions:\n";

Stdio.printf " Only_labels (full): %s\n" (dim_to_string Only_labels (Dim solved_dim_full));

Stdio.printf " Axis_size (full): %s\n" (dim_to_string Axis_size (Dim solved_dim_full));

Stdio.printf " Projection_and_size (full): %s\n" (dim_to_string Projection_and_size (Dim solved_dim_full));

Stdio.printf " Only_labels (minimal): %s\n" (dim_to_string Only_labels (Dim solved_dim_minimal));

Stdio.printf " Axis_size (minimal): %s\n" (dim_to_string Axis_size (Dim solved_dim_minimal));

Stdio.printf "\nVariable dimensions:\n";

Stdio.printf " Only_labels (labeled var): %s\n" (dim_to_string Only_labels (Var var_dim_labeled));

Stdio.printf " Axis_size (labeled var): %s\n" (dim_to_string Axis_size (Var var_dim_labeled));

Stdio.printf " Projection_and_size (labeled var): %s\n" (dim_to_string Projection_and_size (Var var_dim_labeled));

Stdio.printf " Only_labels (unlabeled var): %s\n" (dim_to_string Only_labels (Var var_dim_unlabeled));

Stdio.printf " Axis_size (unlabeled var): %s\n" (dim_to_string Axis_size (Var var_dim_unlabeled))

let test_shape_to_string () =

let open Ocannl in

Stdio.printf "\n=== Testing Shape.to_string_hum ===\n";

(* Create a simple shape *)

let shape = Shape.make

~batch_dims:[1]

~input_dims:[784]

~output_dims:[10; 5]

~debug_name:"test_shape"

~id:42

() in

Stdio.printf "Shape with batch=[1], input=[784], output=[10,5]:\n";

Stdio.printf " Only_labels: %s\n" (Shape.to_string_hum ~style:Row.Only_labels shape);

Stdio.printf " Axis_size: %s\n" (Shape.to_string_hum ~style:Row.Axis_size shape);

Stdio.printf " Axis_number_and_size: %s\n" (Shape.to_string_hum ~style:Row.Axis_number_and_size shape);

Stdio.printf " Projection_and_size: %s\n" (Shape.to_string_hum ~style:Row.Projection_and_size shape);

(* Test default style *)

Stdio.printf " Default style: %s\n" (Shape.to_string_hum shape)

let () =

test_print_styles ();

test_shape_to_string ()