├── docs ├── .gitignore ├── src │ ├── compilation │ │ ├── mir │ │ │ └── context.md │ │ ├── thir │ │ │ ├── enums.md │ │ │ ├── captures.md │ │ │ ├── option-types.md │ │ │ ├── comprehension.md │ │ │ ├── overloading.md │ │ │ ├── transform.md │ │ │ └── records.md │ │ ├── interpreter.md │ │ └── bytecode-gen.md │ ├── examples │ │ └── simple-model.mzn │ ├── interpreter.md │ └── mzn-syntax.md ├── theme │ └── head.hbs └── book.toml ├── parsers ├── tree-sitter-minizinc │ ├── README.md │ ├── .editorconfig │ ├── bindings │ │ ├── python │ │ │ ├── tree_sitter_minizinc │ │ │ │ ├── py.typed │ │ │ │ └── __init__.pyi │ │ │ └── tests │ │ │ │ └── test_binding.py │ │ ├── node │ │ │ └── binding_test.js │ │ ├── swift │ │ │ └── TreeSitterMinizinc │ │ │ │ └── minizinc.h │ │ ├── c │ │ │ ├── tree_sitter │ │ │ │ └── tree-sitter-minizinc.h │ │ │ └── tree-sitter-minizinc.pc.in │ │ └── go │ │ │ ├── binding.go │ │ │ └── binding_test.go │ ├── queries │ │ ├── case_expressions.scm │ │ ├── comments.scm │ │ ├── identifiers.scm │ │ └── tags.scm │ ├── .gitattributes │ └── go.mod ├── tree-sitter-eprime │ ├── .editorconfig │ ├── bindings │ │ ├── python │ │ │ ├── tree_sitter_eprime │ │ │ │ ├── py.typed │ │ │ │ └── __init__.pyi │ │ │ └── tests │ │ │ │ └── test_binding.py │ │ ├── node │ │ │ └── binding_test.js │ │ ├── c │ │ │ ├── tree_sitter │ │ │ │ └── tree-sitter-eprime.h │ │ │ └── tree-sitter-eprime.pc.in │ │ ├── swift │ │ │ └── TreeSitterEprime │ │ │ │ └── eprime.h │ │ └── go │ │ │ ├── binding.go │ │ │ └── binding_test.go │ ├── go.mod │ └── .gitattributes └── tree-sitter-datazinc │ ├── .editorconfig │ ├── bindings │ ├── python │ │ ├── tree_sitter_datazinc │ │ │ ├── py.typed │ │ │ └── __init__.pyi │ │ └── tests │ │ │ └── test_binding.py │ ├── node │ │ └── binding_test.js │ ├── swift │ │ └── TreeSitterDatazinc │ │ │ └── datazinc.h │ ├── c │ │ ├── tree_sitter │ │ │ └── tree-sitter-datazinc.h │ │ └── tree-sitter-datazinc.pc.in │ └── go │ │ ├── binding.go │ │ └── binding_test.go │ ├── go.mod │ └── .gitattributes ├── editors └── code │ ├── .eslintignore │ ├── .gitignore │ ├── src │ └── utils.ts │ ├── tsconfig.json │ └── .vscodeignore ├── crates ├── shackle-compiler │ └── src │ │ ├── syntax │ │ └── ast │ │ │ └── types.rs │ │ ├── constants │ │ └── mod.rs │ │ ├── hir │ │ └── lower │ │ │ └── eprime │ │ │ └── mod.rs │ │ └── thir │ │ └── ir │ │ └── traverse │ │ └── mod.rs ├── xcsp3-serde │ └── corpus │ │ ├── xcsp3_ex_020.xml │ │ ├── xcsp3_ex_150.xml │ │ ├── xcsp3_ex_084.xml │ │ ├── xcsp3_ex_185.xml │ │ ├── xcsp3_ex_050.xml │ │ ├── xcsp3_ex_183.xml │ │ ├── xcsp3_ex_009.xml │ │ ├── xcsp3_ex_082.xml │ │ ├── xcsp3_ex_138.xml │ │ ├── xcsp3_ex_169.xml │ │ ├── xcsp3_ex_008.xml │ │ ├── xcsp3_ex_105.xml │ │ ├── xcsp3_ex_104.xml │ │ ├── xcsp3_ex_122.xml │ │ ├── xcsp3_ex_106.xml │ │ ├── xcsp3_ex_120.xml │ │ ├── xcsp3_ex_038.xml │ │ ├── xcsp3_ex_087.xml │ │ ├── xcsp3_ex_107.xml │ │ ├── xcsp3_ex_121.xml │ │ ├── xcsp3_ex_181.xml │ │ ├── xcsp3_ex_182.xml │ │ ├── xcsp3_ex_012.xml │ │ ├── xcsp3_ex_016.xml │ │ ├── xcsp3_ex_079.xml │ │ ├── xcsp3_ex_080.xml │ │ ├── xcsp3_ex_139.xml │ │ ├── xcsp3_ex_070.xml │ │ ├── xcsp3_ex_026.xml │ │ ├── xcsp3_ex_027.xml │ │ ├── xcsp3_ex_028.xml │ │ ├── xcsp3_ex_081.xml │ │ ├── xcsp3_ex_083.xml │ │ ├── xcsp3_ex_151.xml │ │ ├── xcsp3_ex_023.xml │ │ ├── xcsp3_ex_025.xml │ │ ├── xcsp3_ex_039.xml │ │ ├── xcsp3_ex_096.xml │ │ ├── xcsp3_ex_123.xml │ │ ├── xcsp3_ex_010.xml │ │ ├── xcsp3_ex_088.xml │ │ ├── xcsp3_ex_103.xml │ │ ├── xcsp3_ex_118.xml │ │ ├── xcsp3_ex_011.xml │ │ ├── xcsp3_ex_013.xml │ │ ├── xcsp3_ex_117.xml │ │ ├── xcsp3_ex_149.xml │ │ ├── xcsp3_ex_022.xml │ │ ├── xcsp3_ex_040.xml │ │ ├── xcsp3_ex_102.xml │ │ ├── xcsp3_ex_115.xml │ │ ├── xcsp3_ex_116.xml │ │ ├── xcsp3_ex_146.xml │ │ ├── xcsp3_ex_184.xml │ │ ├── xcsp3_ex_140.xml │ │ ├── xcsp3_ex_147.xml │ │ ├── xcsp3_ex_190.xml │ │ ├── xcsp3_ex_186.xml │ │ ├── xcsp3_ex_007.xml │ │ ├── xcsp3_ex_078.xml │ │ ├── xcsp3_ex_129.xml │ │ ├── xcsp3_ex_144.xml │ │ ├── xcsp3_ex_031.xml │ │ ├── xcsp3_ex_046.xml │ │ ├── xcsp3_ex_073.xml │ │ ├── xcsp3_ex_091.xml │ │ ├── xcsp3_ex_163.xml │ │ ├── xcsp3_ex_114.xml │ │ ├── xcsp3_ex_131.xml │ │ ├── xcsp3_ex_165.xml │ │ ├── xcsp3_ex_042.xml │ │ ├── xcsp3_ex_071.xml │ │ ├── xcsp3_ex_090.xml │ │ ├── xcsp3_ex_128.xml │ │ ├── xcsp3_ex_152.xml │ │ ├── xcsp3_ex_162.xml │ │ ├── xcsp3_ex_187.xml │ │ ├── xcsp3_ex_191.xml │ │ ├── xcsp3_ex_047.xml │ │ ├── xcsp3_ex_094.xml │ │ ├── xcsp3_ex_099.xml │ │ ├── xcsp3_ex_124.xml │ │ ├── xcsp3_ex_045.xml │ │ ├── xcsp3_ex_188.xml │ │ ├── xcsp3_ex_098.xml │ │ ├── xcsp3_ex_164.xml │ │ ├── xcsp3_ex_018.xml │ │ ├── xcsp3_ex_033.xml │ │ ├── xcsp3_ex_036.xml │ │ ├── xcsp3_ex_101.xml │ │ ├── xcsp3_ex_130.xml │ │ ├── xcsp3_ex_148.xml │ │ ├── xcsp3_ex_029.xml │ │ ├── xcsp3_ex_032.xml │ │ ├── xcsp3_ex_051.xml │ │ ├── xcsp3_ex_069.xml │ │ ├── xcsp3_ex_095.xml │ │ ├── xcsp3_ex_034.xml │ │ ├── xcsp3_ex_056.xml │ │ ├── xcsp3_ex_086.xml │ │ ├── xcsp3_ex_133.xml │ │ ├── xcsp3_ex_137.xml │ │ ├── xcsp3_ex_175.xml │ │ ├── xcsp3_ex_068.xml │ │ ├── xcsp3_ex_072.xml │ │ ├── xcsp3_ex_168.xml │ │ ├── xcsp3_ex_006.xml │ │ ├── xcsp3_ex_024.xml │ │ ├── xcsp3_ex_021.xml │ │ ├── xcsp3_ex_054.xml │ │ ├── xcsp3_ex_048.xml │ │ ├── xcsp3_ex_055.xml │ │ ├── xcsp3_ex_092.xml │ │ ├── xcsp3_ex_093.xml │ │ ├── xcsp3_ex_097.xml │ │ ├── xcsp3_ex_153.xml │ │ ├── xcsp3_ex_052.xml │ │ ├── xcsp3_ex_067.xml │ │ ├── xcsp3_ex_014.xml │ │ ├── xcsp3_ex_143.xml │ │ ├── xcsp3_ex_015.xml │ │ ├── xcsp3_ex_053.xml │ │ ├── xcsp3_ex_061.xml │ │ ├── xcsp3_ex_066.xml │ │ ├── xcsp3_ex_089.xml │ │ ├── xcsp3_ex_060.xml │ │ ├── xcsp3_ex_062.xml │ │ ├── xcsp3_ex_156.xml │ │ ├── xcsp3_ex_075.xml │ │ ├── xcsp3_ex_109.xml │ │ ├── xcsp3_ex_076.xml │ │ ├── xcsp3_ex_113.xml │ │ ├── xcsp3_ex_145.xml │ │ ├── xcsp3_ex_035.xml │ │ ├── xcsp3_ex_126.xml │ │ ├── xcsp3_ex_044.xml │ │ ├── xcsp3_ex_077.xml │ │ ├── xcsp3_ex_108.xml │ │ ├── xcsp3_ex_119.xml │ │ ├── xcsp3_ex_110.xml │ │ ├── xcsp3_ex_112.xml │ │ ├── xcsp3_ex_134.xml │ │ ├── xcsp3_ex_125.xml │ │ ├── xcsp3_ex_074.xml │ │ ├── xcsp3_ex_017.xml │ │ ├── xcsp3_ex_043.xml │ │ ├── xcsp3_ex_135.xml │ │ ├── xcsp3_ex_030.xml │ │ ├── xcsp3_ex_085.xml │ │ ├── xcsp3_ex_111.xml │ │ ├── xcsp3_ex_179.xml │ │ ├── xcsp3_ex_041.xml │ │ ├── xcsp3_ex_063.xml │ │ ├── xcsp3_ex_064.xml │ │ ├── xcsp3_ex_100.xml │ │ ├── xcsp3_ex_049.xml │ │ ├── xcsp3_ex_065.xml │ │ ├── knapsack.xml │ │ ├── xcsp3_ex_005.xml │ │ ├── xcsp3_ex_037.xml │ │ ├── xcsp3_ex_136.xml │ │ ├── xcsp3_ex_023.debug.txt │ │ ├── xcsp3_ex_027.debug.txt │ │ ├── xcsp3_ex_127.xml │ │ └── xcsp3_ex_059.xml └── flatzinc-serde │ └── corpus │ └── encapsulated_string.fzn.json ├── .clippy.toml ├── .prettierrc ├── share └── minizinc │ └── std │ ├── fzn_regular_regexp.mzn │ ├── regular_set.mzn │ ├── analyse_all_different.mzn │ ├── fzn_disjoint.mzn │ ├── redefinitions.mzn │ ├── fzn_among.mzn │ ├── fzn_disjoint_reif.mzn │ ├── fzn_at_most1.mzn │ ├── atmost1.mzn │ ├── fzn_alldifferent_except_0.mzn │ ├── fzn_link_set_to_booleans.mzn │ ├── fzn_seq_precede_chain_set_reif.mzn │ ├── fzn_among_reif.mzn │ ├── alldifferent.mzn │ ├── fzn_all_disjoint.mzn │ ├── fzn_seq_precede_chain_int_reif.mzn │ ├── fzn_sum_set.mzn │ ├── fzn_symmetric_all_different.mzn │ ├── fzn_at_most1_reif.mzn │ ├── fzn_link_set_to_booleans_reif.mzn │ ├── alldifferent_except.mzn │ ├── fzn_nvalue.mzn │ ├── fzn_value_precede_int_reif.mzn │ ├── fzn_value_precede_set_reif.mzn │ ├── alldifferent_except_0.mzn │ ├── fzn_all_disjoint_reif.mzn │ ├── fzn_sort_reif.mzn │ ├── fzn_alldifferent_except_0_reif.mzn │ ├── fzn_circuit_reif.mzn │ ├── fzn_count_eq.mzn │ ├── fzn_sum_set_reif.mzn │ ├── fzn_value_precede_chain_set_reif.mzn │ ├── fzn_dag_reif.mzn │ ├── fzn_partition_set.mzn │ ├── fzn_value_precede_chain_int_reif.mzn │ ├── fzn_disjunctive_strict_opt.mzn │ ├── fzn_count_eq_par.mzn │ ├── fzn_count_geq_par.mzn │ ├── fzn_count_gt_par.mzn │ ├── fzn_count_leq_par.mzn │ ├── fzn_count_lt_par.mzn │ ├── fzn_count_neq_par.mzn │ ├── fzn_nvalue_reif.mzn │ ├── count.mzn │ ├── fzn_distribute.mzn │ ├── output.mzn │ ├── fzn_count_eq_reif.mzn │ ├── fzn_global_cardinality_set.mzn │ ├── fzn_regular_reif.mzn │ ├── fzn_alternative.mzn │ ├── fzn_cumulative_opt.mzn │ ├── fzn_partition_set_reif.mzn │ ├── fzn_inverse.mzn │ ├── fzn_regular_set_reif.mzn │ ├── fzn_subcircuit_reif.mzn │ ├── fzn_arg_min_bool_opt.mzn │ ├── nvalue.mzn │ ├── disjoint.mzn │ ├── fzn_alldifferent_except_reif.mzn │ ├── fzn_arg_max_bool_opt.mzn │ ├── fzn_regular_nfa_reif.mzn │ ├── fzn_disjunctive_strict.mzn │ ├── fzn_arg_max_float_opt.mzn │ ├── fzn_arg_min_float_opt.mzn │ ├── fzn_lex_chain_less_int.mzn │ ├── fzn_regular_nfa_set_reif.mzn │ ├── fzn_disjunctive.mzn │ ├── fzn_lex_chain_less_bool.mzn │ ├── fzn_symmetric_all_different_reif.mzn │ ├── fzn_write.mzn │ ├── fzn_lex_chain_lesseq_bool.mzn │ ├── fzn_lex_chain_lesseq_int.mzn │ ├── fzn_value_precede_chain_set.mzn │ ├── fzn_count_eq_par_reif.mzn │ ├── fzn_count_gt_par_reif.mzn │ ├── fzn_count_lt_par_reif.mzn │ ├── fzn_set_member.mzn │ ├── fzn_cost_regular_reif.mzn │ ├── fzn_count_geq_par_reif.mzn │ ├── fzn_count_leq_par_reif.mzn │ ├── fzn_count_neq_par_reif.mzn │ ├── fzn_sum_pred.mzn │ ├── fzn_value_precede_int_opt.mzn │ ├── all_disjoint.mzn │ ├── fzn_distribute_reif.mzn │ ├── nvalue_fn.mzn │ ├── fzn_arg_sort_int.mzn │ ├── fzn_regular_set.mzn.deprecated.mzn │ ├── fzn_alternative_reif.mzn │ ├── fzn_arg_sort_float.mzn │ ├── fzn_geost_nonoverlap_k.mzn │ ├── fzn_global_cardinality.mzn │ ├── fzn_lex2.mzn │ ├── fzn_roots.mzn │ ├── lex2.mzn │ ├── fzn_array_int_union.mzn │ ├── fzn_disjunctive_strict_reif.mzn │ ├── fzn_global_cardinality_closed.mzn │ ├── fzn_write_reif.mzn │ ├── fzn_global_cardinality_closed_set.mzn │ ├── fzn_set_member_reif.mzn │ ├── fzn_span.mzn │ ├── fzn_strict_lex2.mzn │ ├── partition_set.mzn │ ├── fzn_connected_reif.mzn │ ├── fzn_dconnected_reif.mzn │ ├── fzn_lex_chain_less_bool_reif.mzn │ ├── fzn_lex_chain_less_int_reif.mzn │ ├── fzn_piecewise_linear_reif.mzn │ ├── fzn_sum_pred_reif.mzn │ ├── fzn_inverse_opt.mzn │ ├── fzn_lex_chain_lesseq_int_reif.mzn │ ├── fzn_member_int.mzn │ ├── fzn_wst_reif.mzn │ ├── fzn_arg_max_int_opt.mzn │ ├── fzn_arg_min_int_opt.mzn │ ├── fzn_global_cardinality_closed_opt.mzn │ ├── fzn_inverse_reif.mzn │ ├── fzn_knapsack.mzn │ ├── fzn_lex_chain_lesseq_bool_reif.mzn │ ├── fzn_member_bool.mzn │ ├── fzn_disjunctive_opt.mzn │ ├── fzn_dtree_reif.mzn │ ├── fzn_member_float.mzn │ ├── among.mzn │ ├── fzn_all_equal_int.mzn │ ├── fzn_arg_sort_int_reif.mzn │ ├── fzn_circuit_opt.mzn │ ├── fzn_geost_nonoverlap_k_reif.mzn │ ├── fzn_member_set.mzn │ ├── fzn_subgraph.mzn │ ├── lex2_strict.mzn │ ├── strict_lex2.mzn │ ├── fzn_all_equal_set.mzn │ ├── fzn_arg_sort_float_reif.mzn │ ├── fzn_connected.mzn │ ├── fzn_dconnected.mzn │ ├── fzn_inverse_in_range_reif.mzn │ ├── fzn_inverse_set.mzn │ ├── fzn_lex2_reif.mzn │ ├── fzn_all_different_int.mzn │ ├── fzn_bounded_path.mzn │ ├── fzn_disjunctive_reif.mzn │ ├── fzn_dpath_reif.mzn │ ├── fzn_dreachable_reif.mzn │ ├── fzn_global_cardinality_closed_reif.mzn │ ├── fzn_global_cardinality_reif.mzn │ ├── fzn_roots_reif.mzn │ ├── fzn_span_reif.mzn │ ├── roots_fn.mzn │ ├── fzn_exactly_int.mzn │ ├── fzn_all_different_set.mzn │ ├── fzn_range.mzn │ ├── fzn_strict_lex2_reif.mzn │ ├── fzn_tree_reif.mzn │ ├── at_most1.mzn │ ├── fzn_bounded_dpath.mzn │ ├── fzn_dwst_reif.mzn │ ├── fzn_global_cardinality_low_up_closed_set.mzn │ ├── fzn_global_cardinality_low_up_reif.mzn │ ├── fzn_global_cardinality_low_up_set.mzn │ ├── set_member.mzn │ ├── fzn_all_equal_int_reif.mzn │ ├── fzn_count_neq.mzn │ ├── sort_fn.mzn │ ├── circuit_opt.mzn │ ├── fzn_bin_packing.mzn │ ├── fzn_disjunctive_strict_opt_decomp.mzn │ ├── fzn_knapsack_reif.mzn │ ├── fzn_value_precede_chain_int_opt.mzn │ ├── fzn_all_different_int_reif.mzn │ ├── fzn_bin_packing_reif.mzn │ ├── fzn_decreasing_int.mzn │ ├── fzn_global_cardinality_low_up_closed_opt.mzn │ ├── fzn_increasing_int.mzn │ ├── fzn_member_int_reif.mzn │ ├── fzn_strictly_decreasing_bool.mzn │ ├── fzn_strictly_decreasing_int.mzn │ ├── fzn_strictly_increasing_bool.mzn │ ├── fzn_strictly_increasing_int.mzn │ ├── sliding_sum.mzn │ ├── fzn_all_equal_set_reif.mzn │ ├── fzn_at_most_set.mzn │ ├── fzn_circuit_opt_reif.mzn │ ├── fzn_decreasing_bool.mzn │ ├── fzn_decreasing_float.mzn │ ├── fzn_decreasing_set.mzn │ ├── fzn_disjunctive_opt_reif.mzn │ ├── fzn_exactly_set.mzn │ ├── fzn_increasing_bool.mzn │ ├── fzn_increasing_float.mzn │ ├── fzn_increasing_set.mzn │ ├── fzn_member_bool_reif.mzn │ ├── fzn_subgraph_reif.mzn │ ├── redefinitions-2.2.1.mzn │ ├── circuit.mzn │ ├── fzn_at_least_set.mzn │ ├── fzn_dsteiner_reif.mzn │ ├── fzn_inverse_set_reif.mzn │ ├── fzn_member_float_reif.mzn │ ├── fzn_member_set_reif.mzn │ ├── fzn_steiner_reif.mzn │ ├── fzn_all_different_set_reif.mzn │ ├── fzn_global_cardinality_opt.mzn │ ├── fzn_int_set_channel.mzn │ ├── fzn_bounded_path_reif.mzn │ ├── fzn_increasing_bool_opt.mzn │ ├── among_fn.mzn │ ├── fzn_bounded_dpath_reif.mzn │ ├── fzn_disjunctive_strict_opt_reif.mzn │ ├── fzn_dsteiner.mzn │ ├── fzn_if_then_else_bool.mzn │ ├── fzn_if_then_else_int.mzn │ ├── fzn_path_reif.mzn │ ├── fzn_range_reif.mzn │ ├── fzn_decreasing_int_reif.mzn │ ├── fzn_exactly_int_reif.mzn │ ├── fzn_if_then_else_float.mzn │ ├── fzn_increasing_int_reif.mzn │ ├── exactly_int.mzn │ ├── fzn_at_most_set_reif.mzn │ ├── fzn_decreasing_bool_reif.mzn │ ├── fzn_decreasing_float_reif.mzn │ ├── fzn_diffn.mzn │ ├── fzn_exactly_set_reif.mzn │ ├── fzn_if_then_else_set.mzn │ ├── fzn_if_then_else_var_int.mzn │ ├── fzn_increasing_bool_reif.mzn │ ├── fzn_increasing_float_reif.mzn │ ├── fzn_strictly_decreasing_bool_reif.mzn │ ├── fzn_strictly_decreasing_int_opt.mzn │ ├── fzn_strictly_decreasing_int_reif.mzn │ ├── fzn_strictly_increasing_bool_reif.mzn │ ├── fzn_strictly_increasing_int_reif.mzn │ ├── fzn_at_least_set_reif.mzn │ ├── fzn_if_then_else_opt_int.mzn │ ├── fzn_if_then_else_var_bool.mzn │ ├── redefinitions-2.1.mzn │ ├── count_fn.mzn │ ├── exactly_set.mzn │ ├── fzn_count_gt_reif.mzn │ ├── fzn_count_leq.mzn │ ├── fzn_count_lt.mzn │ ├── fzn_count_lt_reif.mzn │ ├── fzn_if_then_else_opt_bool.mzn │ ├── fzn_if_then_else_opt_float.mzn │ ├── fzn_if_then_else_var_float.mzn │ ├── fzn_seq_precede_chain_int.mzn │ ├── fzn_sort.mzn │ ├── fzn_count_geq_reif.mzn │ ├── fzn_count_leq_reif.mzn │ ├── fzn_count_neq_reif.mzn │ ├── fzn_diffn_nonstrict.mzn │ ├── fzn_if_then_else_var_opt_int.mzn │ ├── fzn_if_then_else_var_set.mzn │ ├── sort.mzn │ ├── fzn_bin_packing_capa.mzn │ ├── fzn_if_then_else_var_opt_bool.mzn │ ├── fzn_value_precede_int.mzn │ ├── fzn_global_cardinality_low_up_closed.mzn │ ├── fzn_if_then_else_var_opt_float.mzn │ ├── fzn_decreasing_set_reif.mzn │ ├── fzn_global_cardinality_low_up_opt.mzn │ ├── fzn_increasing_set_reif.mzn │ ├── fzn_steiner.mzn │ ├── sum_set.mzn │ ├── at_most_set.mzn │ └── fzn_arg_min_bool.mzn ├── rustfmt.toml └── .prettierignore /docs/.gitignore: -------------------------------------------------------------------------------- 1 | book 2 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/README.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /editors/code/.eslintignore: -------------------------------------------------------------------------------- 1 | node_modules/** -------------------------------------------------------------------------------- /crates/shackle-compiler/src/syntax/ast/types.rs: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/src/compilation/mir/context.md: -------------------------------------------------------------------------------- 1 | # Context analysis 2 | -------------------------------------------------------------------------------- /docs/src/compilation/thir/enums.md: -------------------------------------------------------------------------------- 1 | # Erasure of enums 2 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/.editorconfig: -------------------------------------------------------------------------------- 1 | root = false 2 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/.editorconfig: -------------------------------------------------------------------------------- 1 | root = false 2 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/.editorconfig: -------------------------------------------------------------------------------- 1 | root = false 2 | -------------------------------------------------------------------------------- /docs/src/compilation/interpreter.md: -------------------------------------------------------------------------------- 1 | # Bytecode interpretation 2 | -------------------------------------------------------------------------------- /docs/src/compilation/thir/captures.md: -------------------------------------------------------------------------------- 1 | # Desugaring of capturing 2 | -------------------------------------------------------------------------------- /editors/code/.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | out 3 | package-lock.json -------------------------------------------------------------------------------- /docs/src/compilation/thir/option-types.md: -------------------------------------------------------------------------------- 1 | # Erasure of option types 2 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/python/tree_sitter_eprime/py.typed: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/src/compilation/thir/comprehension.md: -------------------------------------------------------------------------------- 1 | # Desugaring of comprehensions 2 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/python/tree_sitter_datazinc/py.typed: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/python/tree_sitter_minizinc/py.typed: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.clippy.toml: -------------------------------------------------------------------------------- 1 | doc-valid-idents = ["DataZinc", "MicroZinc", "MiniZinc", ".."] 2 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/queries/case_expressions.scm: -------------------------------------------------------------------------------- 1 | (case_expression) @case 2 | -------------------------------------------------------------------------------- /.prettierrc: -------------------------------------------------------------------------------- 1 | { 2 | "trailingComma": "es5", 3 | "useTabs": true, 4 | "semi": false 5 | } 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_020.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_150.xml: -------------------------------------------------------------------------------- 1 | eq(add(%0,%1),%2) 2 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_084.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 @not@(x1) x2 x3 @not@(x4) 3 | 4 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_185.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /docs/src/examples/simple-model.mzn: -------------------------------------------------------------------------------- 1 | test foo() = true; 2 | function bool: bar() = true; 3 | var 1..3: x; -------------------------------------------------------------------------------- /share/minizinc/std/fzn_regular_regexp.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_regular(array [int] of var int: x, string: r); 2 | -------------------------------------------------------------------------------- /share/minizinc/std/regular_set.mzn: -------------------------------------------------------------------------------- 1 | include "regular.mzn"; 2 | 3 | % TODO: File no longer necessary. 4 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_050.xml: -------------------------------------------------------------------------------- 1 | x1 x2 x3 x4 2 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_183.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/queries/comments.scm: -------------------------------------------------------------------------------- 1 | [ 2 | (line_comment) 3 | (block_comment) 4 | ] @comment 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_009.xml: -------------------------------------------------------------------------------- 1 | 2 5 8 9 12 15 22 25 30 50 2 | 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_082.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 x1 x2 x3 3 | r 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_138.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | x1 x2 x3 x4 x5 4 | 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_169.xml: -------------------------------------------------------------------------------- 1 | 2 | if(eq(x,y),0.5,0) 3 | 4 | -------------------------------------------------------------------------------- /share/minizinc/std/analyse_all_different.mzn: -------------------------------------------------------------------------------- 1 | predicate analyse_all_different(array [int] of var opt int: x) = true; 2 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_008.xml: -------------------------------------------------------------------------------- 1 | 0..+infinity 2 | -infinity..+infinity 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_105.xml: -------------------------------------------------------------------------------- 1 | 2 | x y 3 | b a 4 | 2 | x y 3 | o m 4 | 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjoint.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjoint(var set of int: s1, var set of int: s2) = 2 | s1 intersect s2 == {}; 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_122.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | 4 | -------------------------------------------------------------------------------- /rustfmt.toml: -------------------------------------------------------------------------------- 1 | group_imports = "StdExternalCrate" 2 | hard_tabs = true 3 | imports_granularity = "Crate" 4 | reorder_impl_items = true 5 | -------------------------------------------------------------------------------- /share/minizinc/std/redefinitions.mzn: -------------------------------------------------------------------------------- 1 | % This file contains redefinitions of standard builtins that can be overridden 2 | % by solvers. 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_106.xml: -------------------------------------------------------------------------------- 1 | 2 | x y 3 | dc ec 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_120.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 3 | 4 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_038.xml: -------------------------------------------------------------------------------- 1 | 2 | x 3 | 1 2 4 8..10 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_087.xml: -------------------------------------------------------------------------------- 1 | 2 | w[] 3 | 0x3 1x3 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_107.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 3 | [30,40] [60,+infinity[ 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_121.xml: -------------------------------------------------------------------------------- 1 | 2 | X[] 3 | 4 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_181.xml: -------------------------------------------------------------------------------- 1 | 4 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_182.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 x1 x2 3 | y z 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_012.xml: -------------------------------------------------------------------------------- 1 | 2 | 1 5 3 | 3 6 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_016.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_079.xml: -------------------------------------------------------------------------------- 1 | 2 | y0 y1 y2 y3 y4 3 | (eq,2) 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_080.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 x1 x2 x3 3 | s 4 | f 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_139.xml: -------------------------------------------------------------------------------- 1 | 2 | eq(x,10) 3 | y[] 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_070.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 y4 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_026.xml: -------------------------------------------------------------------------------- 1 | 2 | x[] 3 | 1 1 2 * 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_027.xml: -------------------------------------------------------------------------------- 1 | 2 | x[] 3 | 1 1 2 1 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_028.xml: -------------------------------------------------------------------------------- 1 | 2 | x[] 3 | 1x2 2 1 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_081.xml: -------------------------------------------------------------------------------- 1 | 2 | y0 y1 y2 y3 y4 y5 y6 y7 3 | (eq,k) 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_083.xml: -------------------------------------------------------------------------------- 1 | 2 | y0 y1 y2 y3 y4 y5 y6 y7 3 | (eq,k) 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_151.xml: -------------------------------------------------------------------------------- 1 | 2 | %0 %1 3 | (1,2)(2,1)(2,3)(3,1)(3,2)(3,3) 4 | 5 | -------------------------------------------------------------------------------- /docs/src/interpreter.md: -------------------------------------------------------------------------------- 1 | # The MicroZinc Interpreter 2 | 3 | ## Builtin functions 4 | 5 | The following functions have been included as builtin functions for 6 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/go.mod: -------------------------------------------------------------------------------- 1 | module git+github.com/shackle-rs/shackle.git 2 | 3 | go 1.22 4 | 5 | require github.com/tree-sitter/go-tree-sitter v0.24.0 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_among.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_among(var int: n, array [int] of var int: x, set of int: v) = 2 | n == sum (i in index_set(x)) (x[i] in v); 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_023.xml: -------------------------------------------------------------------------------- 1 | 2 | b c 3 | 2 2 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_025.xml: -------------------------------------------------------------------------------- 1 | 2 | x[0] x[1] x[2] 3 | 1 1 2 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_039.xml: -------------------------------------------------------------------------------- 1 | 2 | z1 z2 z3 z4 3 | (1,*,1,2)(2,1,*,*) 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_096.xml: -------------------------------------------------------------------------------- 1 | 2 | s 3 | 4 2 3 2 7 4 | (gt,v) 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_123.xml: -------------------------------------------------------------------------------- 1 | 2 | X[] 3 | (eq,2) 4 | 5 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/go.mod: -------------------------------------------------------------------------------- 1 | module git+github.com/shackle-rs/shackle.git 2 | 3 | go 1.22 4 | 5 | require github.com/tree-sitter/go-tree-sitter v0.24.0 6 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/.gitattributes: -------------------------------------------------------------------------------- 1 | /src/** linguist-vendored 2 | 3 | # Zig bindings 4 | build.zig linguist-generated 5 | build.zig.zon linguist-generated 6 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/.gitattributes: -------------------------------------------------------------------------------- 1 | /src/** linguist-vendored 2 | 3 | # Zig bindings 4 | build.zig linguist-generated 5 | build.zig.zon linguist-generated 6 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/go.mod: -------------------------------------------------------------------------------- 1 | module git+github.com/shackle-rs/shackle.git 2 | 3 | go 1.22 4 | 5 | require github.com/tree-sitter/go-tree-sitter v0.24.0 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_010.xml: -------------------------------------------------------------------------------- 1 | green orange red 2 | tom oliver john marc 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_088.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 3 | (a,b,a)(b,a,c)(b,c,b)(c,a,b) 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_103.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 x1 x2 3 | 1.5 2 3.2 4 | (gt,y) 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_118.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | x[][] 4 | 5 | i j 6 | 5 7 | 8 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/queries/identifiers.scm: -------------------------------------------------------------------------------- 1 | [ 2 | (identifier) 3 | (quoted_identifier) 4 | (type_inst_id) 5 | (type_inst_enum_id) 6 | ] @identifier 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjoint_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjoint_reif( 2 | var set of int: s1, 3 | var set of int: s2, 4 | var bool: b, 5 | ) = b <-> s1 intersect s2 == {}; 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_011.xml: -------------------------------------------------------------------------------- 1 | [0,+infinity[ 2 | [-4,4] 3 | [2/3,8.355] 4 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_013.xml: -------------------------------------------------------------------------------- 1 | 2 | Bob Paul 3 | Emily Luke Susan 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_117.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | x[][] 4 | 5 | i j 6 | (eq,5) 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_149.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 3 | (le,z) 4 | 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_at_most1.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_at_most1(array [int] of var set of int: s) = 2 | forall (i, j in index_set(s) where i < j) (card(s[i] intersect s[j]) <= 1); 3 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_022.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1..10 4 | 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_040.xml: -------------------------------------------------------------------------------- 1 | 2 | w1 w2 w3 w4 3 | (0,{1,2},0,{0,2})(1,0,1,2)(2,{0,2},0,2) 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_102.xml: -------------------------------------------------------------------------------- 1 | 2 | eq(v,sqrt(w)) 3 | 4 | 5 | ge(x,add(mul(3,ln(y)),pow(z,4))) 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_115.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | (x1,x2,x3,x4,x5) 4 | (y1,y2,y3,y4,y5) 5 | (z1,z2,z3,z4,z5) 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_116.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | (z1,z2,z3) 4 | (z4,z5,z6) 5 | (z7,z8,z9) 6 | 7 | le 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_146.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 3 | ne(%0,%1) 4 | z 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_184.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 x7 x12 3 | x10 x20 4 | 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_140.xml: -------------------------------------------------------------------------------- 1 | 2 | eq(x,10) 3 | y[] 4 | y[] 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_147.xml: -------------------------------------------------------------------------------- 1 | 2 | y1 y2 y3 y4 3 | gt(dist(%0,%1),2) 4 | w 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_190.xml: -------------------------------------------------------------------------------- 1 | 2 | z1 z2 z3 z4 3 | (2,*,4,*) : eq(z2,z4) 4 | (3,1,*,2) : le(z3,5) 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_186.xml: -------------------------------------------------------------------------------- 1 | 2 | x 3 | y z 4 | 5 | 6 | -------------------------------------------------------------------------------- /share/minizinc/std/atmost1.mzn: -------------------------------------------------------------------------------- 1 | % The actual definitions are in at_most1.mzn. 2 | % This file is used to handle the case where users include 3 | % "atmost1.mzn"; 4 | % 5 | include "at_most1.mzn"; 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_alldifferent_except_0.mzn: -------------------------------------------------------------------------------- 1 | include "alldifferent_except.mzn"; 2 | 3 | predicate fzn_alldifferent_except_0(array [int] of var int: vs) = 4 | alldifferent_except(vs, {0}); 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_link_set_to_booleans.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_link_set_to_booleans( 2 | var set of int: s, 3 | array [int] of var bool: b, 4 | ) = forall (i in index_set(b)) (b[i] <-> i in s); 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_007.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 0 1 4 | 0 1 5 | 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_078.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x0 x1 x2 x3 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_129.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 3 | 0 2 4 4 | (in,0..1) 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_144.xml: -------------------------------------------------------------------------------- 1 | 2 | dist(x,y) 3 | 4 | 5 | if(le(v,w),0,sqr(sub(v,w))) 6 | 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_seq_precede_chain_set_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_seq_precede_chain_set_reif(array [int] of var set of int: X) = 2 | abort("Reified seq_precede_chain constraint is not supported"); 3 | -------------------------------------------------------------------------------- /crates/shackle-compiler/src/constants/mod.rs: -------------------------------------------------------------------------------- 1 | //! Registries of constants. 2 | //! 3 | //! These are accessible using the database. 4 | mod ids; 5 | mod tys; 6 | 7 | pub use ids::*; 8 | pub use tys::*; 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_031.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | y1 y2 y3 y4 4 | 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_046.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 x5 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_073.xml: -------------------------------------------------------------------------------- 1 | 2 | (x0,y0,z0)(x1,y1,z1)(x2,y2,z2)(x3,y3,z3) 3 | (2,4,1)(4,2,3)(5,1,2)(3,3,2) 4 | 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_091.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | s1 s2 s3 s4 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_163.xml: -------------------------------------------------------------------------------- 1 | 2 | a b c 3 | a b c d e 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_114.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 3 | y1 y2 y3 4 | z1 z2 z3 5 | (eq,2) 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_131.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 3 | 4 | %0 %1 %2 5 | (in,1..3) 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_165.xml: -------------------------------------------------------------------------------- 1 | 2 | ... 3 | (a,b)(a,c)(b,a)(b,c)(c,a)(c,c) 4 | ... 5 | 6 | ... 7 | 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_among_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_among_reif( 2 | var int: n, 3 | array [int] of var int: x, 4 | set of int: v, 5 | var bool: b, 6 | ) = b <-> n == sum (i in index_set(x)) (x[i] in v); 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_042.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 3 | 0 1 2 4 | (S,0 S)(S,1 S)(A,)(A,2 A) 5 | S 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_071.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 x6 x7 3 | morning afternoon night off 4 | 1..3 1..3 2..3 2..4 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_090.xml: -------------------------------------------------------------------------------- 1 | 2 | s1 s2 s3 3 | 4 | 5 | t1 t2 t3 t4 6 | {} 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_128.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 y1 x2 y2 x3 y3 3 | z1 z2 z3 4 | eq(add(%0,%1),%2) 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_152.xml: -------------------------------------------------------------------------------- 1 | 2 | eq(add(%0,%1),%2) 3 | x0 x1 x2 4 | x3 x4 x5 5 | x6 x7 x8 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_162.xml: -------------------------------------------------------------------------------- 1 | 2 | a b c 3 | a b c d e 4 | a b c 5 | a b c d e 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_187.xml: -------------------------------------------------------------------------------- 1 | 2 | c0 c1 c2 3 | c3 c4 4 | 5 | 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_191.xml: -------------------------------------------------------------------------------- 1 | 2 | z1 z2 z3 z4 3 | * : eq(z1,2) eq(z3,4) eq(z2,z4) 4 | * : eq(z1,3) eq(z2,1) eq(z4,2) le(z3,5) 5 | 6 | -------------------------------------------------------------------------------- /share/minizinc/std/alldifferent.mzn: -------------------------------------------------------------------------------- 1 | % The actual definitions are in all_different.mzn. 2 | % This file is used to handle the case where users include 3 | % "alldifferent.mzn"; 4 | % 5 | include "all_different.mzn"; 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_disjoint.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_disjoint.mzn"; 2 | 3 | predicate fzn_all_disjoint(array [int] of var set of int: S) = 4 | forall (i, j in index_set(S) where i < j) (fzn_disjoint(S[i], S[j])); 5 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_047.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | add(x1,1) add(x2,2) add(x3,3) 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_094.xml: -------------------------------------------------------------------------------- 1 | 2 | s1 s2 s3 3 | 4 | 5 | t1 t2 t3 t4 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_099.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 x1 x2 x3 x4 x5 3 | s 4 | {0,1} 5 | 6 | eq(2,card(s)) 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_124.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | 2 4 4 | 1..3 1..3 5 | 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_seq_precede_chain_int_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_seq_precede_chain_int_reif( 2 | array [int] of var int: X, 3 | var bool: b, 4 | ) = abort("Reified seq_precede_chain constraint is not supported"); 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_sum_set.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_sum_set( 2 | array [int] of int: vs, 3 | array [int] of int: ws, 4 | var set of int: x, 5 | var int: s, 6 | ) = s == sum (j in index_set(vs)) ((vs[j] in x) * ws[j]); 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_045.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | add(x1,1) add(x2,2) add(x3,3) 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_188.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /docs/theme/head.hbs: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_symmetric_all_different.mzn: -------------------------------------------------------------------------------- 1 | include "all_different.mzn"; 2 | include "inverse.mzn"; 3 | 4 | predicate fzn_symmetric_all_different(array [int] of var int: x) = 5 | all_different(x) /\ inverse(x, x); 6 | -------------------------------------------------------------------------------- /.prettierignore: -------------------------------------------------------------------------------- 1 | # General build artefacts 2 | build/ 3 | docs/book 4 | node_modules/ 5 | node/ 6 | out/ 7 | package-lock.json 8 | target/ 9 | 10 | # Shackle specific 11 | parsers/tree-sitter-*/src 12 | share/minizinc/ 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_098.xml: -------------------------------------------------------------------------------- 1 | 2 | x0 x1 x2 x3 x4 x5 3 | {0,1,2,3,4,5} 4 | t 5 | 6 | eq(y,card(t)) 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_164.xml: -------------------------------------------------------------------------------- 1 | 2 | ... 3 | (a,b)(a,c)(b,a)(b,c)(c,a)(c,c) 4 | ... 5 | (a,b)(a,c)(b,a)(b,c)(c,a)(c,c) 6 | ... 7 | 8 | -------------------------------------------------------------------------------- /docs/src/compilation/thir/overloading.md: -------------------------------------------------------------------------------- 1 | # Removal of overloading 2 | 3 | Since [`MIR`](../mir/mir.md) does not support overloading, we perform name-mangling to give each 4 | overloaded variant of a function a distinct name. 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_at_most1_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_at_most1_reif(array [int] of var set of int: s, var bool: b) = 2 | b <-> 3 | forall (i, j in index_set(s) where i < j) ( 4 | card(s[i] intersect s[j]) <= 1 5 | ); 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_018.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1..100 4 | 0 1 5 | 6 | 7 | -------------------------------------------------------------------------------- /docs/src/compilation/thir/transform.md: -------------------------------------------------------------------------------- 1 | # Model transformations 2 | 3 | - THIR seems to be a good fit for model level transformations. 4 | - The idea would be to perform some sort of rewriting of the THIR tree to produce a new tree 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_link_set_to_booleans_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_link_set_to_booleans_reif( 2 | var set of int: s, 3 | array [int] of var bool: b, 4 | var bool: bb, 5 | ) = bb <-> forall (i in index_set(b)) (b[i] <-> i in s); 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_033.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | add(s[0],61) add(s[1],9) add(s[2],87) 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /share/minizinc/std/alldifferent_except.mzn: -------------------------------------------------------------------------------- 1 | % The actual definitions are in all_different.mzn. 2 | % This file is used to handle the case where users include 3 | % "alldifferent_except.mzn"; 4 | % 5 | include "all_different_except.mzn"; 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_nvalue.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_nvalue(var int: n, array [int] of var int: x) = 2 | let { 3 | int: lx = lb_array(x); 4 | int: ux = ub_array(x); 5 | } in n == sum (j in lx..ux) (exists (i in index_set(x)) (x[i] = j)); 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_int_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_value_precede_int_reif( 2 | int: s, 3 | int: t, 4 | array [int] of var int: x, 5 | var bool: b, 6 | ) = abort("Reified value_precede/3 for integers is not supported."); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_set_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_value_precede_set_reif( 2 | int: s, 3 | int: t, 4 | array [int] of var set of int: x, 5 | var bool: b, 6 | ) = abort("Reified value_precede/3 for sets is not supported."); 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_036.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | eq(add(x,y),z) 4 | ge(w,z) 5 | 6 | 7 | -------------------------------------------------------------------------------- /share/minizinc/std/alldifferent_except_0.mzn: -------------------------------------------------------------------------------- 1 | % The actual definitions are in all_different.mzn. 2 | % This file is used to handle the case where users include 3 | % "alldifferent_except_0.mzn"; 4 | % 5 | include "all_different_except_0.mzn"; 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_disjoint_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_disjoint.mzn"; 2 | 3 | predicate fzn_all_disjoint_reif(array [int] of var set of int: S, var bool: b) = 4 | b <-> forall (i, j in index_set(S) where i < j) (fzn_disjoint(S[i], S[j])); 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_sort_reif.mzn: -------------------------------------------------------------------------------- 1 | include "sort_fn.mzn"; 2 | 3 | predicate fzn_sort_reif( 4 | array [int] of var int: x, 5 | array [int] of var int: y, 6 | var bool: b, 7 | ) = let { array [int] of var int: s = sort(x) } in b <-> s = y; 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_101.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | s1 s2 s3 s4 5 | 4 0 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_130.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 3 | 4 | %0 %1 %2 5 | 0 2 4 6 | (in,0..1) 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_148.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 x5 3 | 4 | %0 %1 %2 5 | (le,3) 6 | 7 | (in,0..1) 8 | 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_alldifferent_except_0_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_alldifferent_except_reif.mzn"; 2 | 3 | predicate fzn_alldifferent_except_0_reif( 4 | array [int] of var int: vs, 5 | var bool: b, 6 | ) = fzn_alldifferent_except_reif(vs, {0}, b); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_circuit_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_circuit_reif(array [int] of var int: x, var bool: b) = 2 | abort("Reified circuit/1 is not supported."); 3 | 4 | %-----------------------------------------------------------------------------% 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_eq.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_count_eq(array [int] of var int: x, var int: y, var int: c) = 2 | c = sum (i in index_set(x)) (x[i] == y); 3 | 4 | %-----------------------------------------------------------------------------% 5 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_sum_set_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_sum_set_reif( 2 | array [int] of int: vs, 3 | array [int] of int: ws, 4 | var set of int: x, 5 | var int: s, 6 | var bool: b, 7 | ) = b <-> s == sum (j in index_set(vs)) ((j in x) * ws[j]); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_chain_set_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_value_precede_chain_set_reif( 2 | array [int] of int: c, 3 | array [int] of var set of int: x, 4 | var bool: b, 5 | ) = abort("Reified value_precede_chain is not supported"); 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_029.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | z 4 | add(x,mul(y,2)) 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_032.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | add(s[0],61) add(s[1],9) add(s[2],87) 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_051.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 5 | 4 0 1 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_069.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | z0 z1 z2 z3 z4 z5 5 | v 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_095.xml: -------------------------------------------------------------------------------- 1 | 2 | s1 s2 s3 3 | subseq 4 | 5 | 6 | t1 t2 t3 t4 t5 7 | supseq 8 | 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dag_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_dag_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | array [int] of var bool: ns, 5 | array [int] of var bool: es, 6 | var bool: b, 7 | ) = abort("Reified dag is not supported"); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_partition_set.mzn: -------------------------------------------------------------------------------- 1 | include "all_disjoint.mzn"; 2 | 3 | predicate fzn_partition_set( 4 | array [int] of var set of int: S, 5 | set of int: universe, 6 | ) = all_disjoint(S) /\ universe == array_union (i in index_set(S)) (S[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_chain_int_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_value_precede_chain_int_reif( 2 | array [int] of int: T, 3 | array [int] of var int: X, 4 | var bool: b, 5 | ) = abort("Reified value_precede_chain constraint is not supported"); 6 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_034.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | z 4 | add(x,sub(y,10)) 5 | 6 | 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_056.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | eq(x1,1) gt(x2,2) eq(x3,1) 5 | (le,2) 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_086.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | w[] 5 | 0 0 0 1 1 1 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_133.xml: -------------------------------------------------------------------------------- 1 | 2 | eq(x,add(y,z)) 3 | 4 | x z 5 | (0,1)(1,3)(1,2)(1,3)(2,0)(2,2)(3,1) 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_137.xml: -------------------------------------------------------------------------------- 1 | 2 | eq(x,add(y,z)) 3 | 4 | x z 5 | (0,1)(1,3)(1,2)(1,3)(2,0)(2,2)(3,1) 6 | 7 | 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_175.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | ge(x1,y1) 4 | 5 | 6 | ge(x2,add(y2,sub(y1,x1)) 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_068.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x0 x1 x2 x3 x4 5 | y0 y1 y2 y3 y4 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_072.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x0 x1 x2 x3 5 | l0 l1 l2 l3 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_168.xml: -------------------------------------------------------------------------------- 1 | 2 | w x y z 3 | (1,2,3,4)(2,1,2,3)(3,1,3,4) 4 | (1,1,3,4)(2,2,2,2) 5 | 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_strict_opt.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_disjunctive_strict_opt_decomp.mzn"; 2 | 3 | predicate fzn_disjunctive_strict_opt( 4 | array [int] of var opt int: s, 5 | array [int] of var int: d, 6 | ) = fzn_disjunctive_strict_opt_decomp(s, d); 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_006.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 0 1 2 3 4 5 6 4 | 0..6 5 | -6..-2 0 1..3 4 7 8..11 6 | 7 | 8 | -------------------------------------------------------------------------------- /editors/code/src/utils.ts: -------------------------------------------------------------------------------- 1 | import { TextEditor } from "vscode" 2 | 3 | export function isMiniZinc(editor: TextEditor) { 4 | return ( 5 | editor && 6 | editor.document.languageId === "minizinc" && 7 | editor.document.uri.scheme === "file" 8 | ) 9 | } 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_eq_par.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_eq.mzn"; 2 | 3 | predicate fzn_count_eq_par(array [int] of var int: x, int: y, int: c) = 4 | fzn_count_eq(x, y, c); 5 | 6 | %-----------------------------------------------------------------------------% 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_geq_par.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_geq.mzn"; 2 | 3 | predicate fzn_count_geq_par(array [int] of var int: x, int: y, int: c) = 4 | fzn_count_geq(x, y, c); 5 | 6 | %-----------------------------------------------------------------------------% 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_gt_par.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_gt.mzn"; 2 | 3 | predicate fzn_count_gt_par(array [int] of var int: x, int: y, int: c) = 4 | fzn_count_gt(x, y, c); 5 | 6 | %-----------------------------------------------------------------------------% 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_leq_par.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_leq.mzn"; 2 | 3 | predicate fzn_count_leq_par(array [int] of var int: x, int: y, int: c) = 4 | fzn_count_leq(x, y, c); 5 | 6 | %-----------------------------------------------------------------------------% 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_lt_par.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_lt.mzn"; 2 | 3 | predicate fzn_count_lt_par(array [int] of var int: x, int: y, int: c) = 4 | fzn_count_lt(x, y, c); 5 | 6 | %-----------------------------------------------------------------------------% 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_neq_par.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_neq.mzn"; 2 | 3 | predicate fzn_count_neq_par(array [int] of var int: x, int: y, int: c) = 4 | fzn_count_neq(x, y, c); 5 | 6 | %-----------------------------------------------------------------------------% 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_nvalue_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_nvalue_reif(var int: n, array [int] of var int: x, var bool: b) = 2 | let { 3 | int: lx = lb_array(x); 4 | int: ux = ub_array(x); 5 | } in b <-> n == sum (j in lx..ux) (exists (i in index_set(x)) (x[i] = j)); 6 | -------------------------------------------------------------------------------- /share/minizinc/std/count.mzn: -------------------------------------------------------------------------------- 1 | include "count_eq.mzn"; 2 | 3 | /** @group globals.counting 4 | Constrains \a c to be the number of occurrences of \a y in \a x. 5 | */ 6 | predicate count(array [$X] of var $$E: x, var $$E: y, var int: c) = 7 | count_eq(array1d(x), y, c); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_distribute.mzn: -------------------------------------------------------------------------------- 1 | include "count_eq.mzn"; 2 | 3 | predicate fzn_distribute( 4 | array [int] of var int: card, 5 | array [int] of var int: value, 6 | array [int] of var int: base, 7 | ) = forall (i in index_set(card)) (count(base, value[i], card[i])); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/output.mzn: -------------------------------------------------------------------------------- 1 | /*** 2 | @groupdef stdlib.output Stuctured Output 3 | 4 | These functions provide structured output for common structures modelled in the MiniZinc language. 5 | */ 6 | 7 | include "output/gantt.mzn"; 8 | include "output/array2d_bool.mzn"; 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_024.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1..3 4 | 5 | 6 | eq(add(x[0],x[1]),x[2]) 7 | 8 | 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_eq_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_count_eq_reif( 2 | array [int] of var int: x, 3 | var int: y, 4 | var int: c, 5 | var bool: b, 6 | ) = b <-> count_eq(x, y) = c; 7 | 8 | %-----------------------------------------------------------------------------% 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_021.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 1..10 5 | 1..20 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_054.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | w[] 5 | 1x4 2x2 6 | (le,10) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_set.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_global_cardinality_set( 2 | array [int] of var set of int: x, 3 | array [int] of int: cover, 4 | array [int] of var int: counts, 5 | ) = forall (i in index_set(cover)) (counts[i] = count (v in x) (cover[i] in v)); 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_regular_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_regular_reif( 2 | array [int] of var int: x, 3 | int: Q, 4 | int: S, 5 | array [int, int] of int: d, 6 | int: q0, 7 | set of int: F, 8 | var bool: b, 9 | ) = abort("Reified regular constraint is not supported"); 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_048.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 3 | (ge,2) 4 | 5 | 6 | y1 y2 y3 y4 7 | (in,2..4) 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_055.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | w[] 5 | 1 1 1 1 2 2 6 | (le,10) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_092.xml: -------------------------------------------------------------------------------- 1 | 2 | s1 s2 s3 3 | (eq,k) 4 | 5 | 6 | t1 t2 t3 7 | (le,1) 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_093.xml: -------------------------------------------------------------------------------- 1 | 2 | s1 s2 s3 3 | (gt,0) 4 | 5 | 6 | t1 t2 t3 t4 7 | (eq,0) 8 | 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_097.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | s1 s2 s3 s4 5 | t 6 | (eq,2) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_153.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | %0 %1 4 | (1,2)(2,1)(2,3)(3,1)(3,2)(3,3) 5 | 6 | w x 7 | w z 8 | x y 9 | 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_alternative.mzn: -------------------------------------------------------------------------------- 1 | include "span.mzn"; 2 | 3 | predicate fzn_alternative( 4 | var opt int: s0, 5 | var int: d0, 6 | array [int] of var opt int: s, 7 | array [int] of var int: d, 8 | ) = sum (i in index_set(s)) (occurs(s[i])) = occurs(s0) /\ span(s0, d0, s, d); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_cumulative_opt.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_cumulative_opt_decomp.mzn"; 2 | 3 | predicate fzn_cumulative_opt( 4 | array [int] of var opt int: s, 5 | array [int] of var int: d, 6 | array [int] of var int: r, 7 | var int: b, 8 | ) = fzn_cumulative_opt_decomp(s, d, r, b); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_partition_set_reif.mzn: -------------------------------------------------------------------------------- 1 | include "all_disjoint.mzn"; 2 | 3 | predicate fzn_partition_set_reif( 4 | array [int] of var set of int: S, 5 | set of int: universe, 6 | var bool: b, 7 | ) = b <-> all_disjoint(S) /\ universe == array_union (i in index_set(S)) (S[i]); 8 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_052.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 5 | 1 2 3 6 | (gt,y) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_067.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 10 4 7 2 3 5 | i 6 | (eq,v) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/queries/tags.scm: -------------------------------------------------------------------------------- 1 | (function_item name: (identifier) @name) @definition.function 2 | (predicate name: (identifier) @name) @definition.function 3 | (annotation name: (identifier) @name) @definition.function 4 | 5 | (call function: (identifier) @name) @reference.call 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_inverse.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_inverse(array [int] of var int: f, array [int] of var int: invf) = 2 | forall (i in index_set(f)) (f[i] in index_set(invf) /\ invf[f[i]] == i) /\ 3 | forall (j in index_set(invf)) ( 4 | invf[j] in index_set(f) /\ f[invf[j]] == j 5 | ); 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_regular_set_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_regular_reif( 2 | array [int] of var int: x, 3 | int: Q, 4 | set of int: S, 5 | array [int, int] of int: d, 6 | int: q0, 7 | set of int: F, 8 | var bool: b, 9 | ) = abort("Reified regular constraint is not supported"); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_subcircuit_reif.mzn: -------------------------------------------------------------------------------- 1 | include "alldifferent.mzn"; 2 | 3 | predicate fzn_subcircuit_reif(array [int] of var int: x, var bool: b) = 4 | abort("Reified subcircuit/1 is not supported."); 5 | 6 | %-----------------------------------------------------------------------------% 7 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_014.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | a b 4 | (a,b) 5 | 6 | 7 | c 8 | (a,c)(b,c) 9 | 10 | 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_143.xml: -------------------------------------------------------------------------------- 1 | 2 | dist(x,y) 3 | z 4 | 5 | 6 | if(le(v,w),0,sqr(sub(v,w))) 7 | (le,u) 8 | 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_min_bool_opt.mzn: -------------------------------------------------------------------------------- 1 | include "arg_min.mzn"; 2 | 3 | predicate fzn_minimum_arg_bool_opt(array [int] of var opt bool: x, var int: z) = 4 | let { 5 | array [index_set(x)] of var 0..2: dx = 6 | array1d(index_set(x), [xi default 2 | xi in x]); 7 | } in minimum_arg(dx, z); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/nvalue.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_nvalue.mzn"; 2 | include "fzn_nvalue_reif.mzn"; 3 | 4 | /** @group globals.alldifferent 5 | Requires that the number of distinct values in \a x is \a n. 6 | */ 7 | predicate nvalue(var int: n, array [$X] of var int: x) = 8 | fzn_nvalue(n, array1d(x)); 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_015.xml: -------------------------------------------------------------------------------- 1 | 2 | 5:1/6 3 | 15:1/3 4 | 25:1/2 5 | 6 | 7 | 1..6:1/6 8 | 9 | 10 | heads:0.5 11 | tails:0.5 12 | 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_053.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | y1 y2 y3 y4 5 | 4 2 3 1 6 | (in,2..5) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_061.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | (eq,k) 4 | 5 | 6 | y1 y2 y3 y4 y5 7 | 0 1 2 8 | (lt,2) 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_066.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 5 | i 6 | v 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_089.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | eq(card(s),2) 5 | 6 | 7 | subset(union(t1,t2),t3) 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /share/minizinc/std/disjoint.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_disjoint.mzn"; 2 | include "fzn_disjoint_reif.mzn"; 3 | 4 | /** @group globals.set Requires that sets \a s1 and \a s2 do not intersect. */ 5 | predicate disjoint(var set of $$E: s1, var set of $$E: s2) = 6 | fzn_disjoint(erase_enum(s1), erase_enum(s2)); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_alldifferent_except_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_alldifferent_except_reif( 2 | array [int] of var int: vs, 3 | set of int: S, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i, j in index_set(vs) where i < j) ( 8 | vs[i] in S /\ vs[j] in S \/ vs[i] != vs[j] 9 | ); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_max_bool_opt.mzn: -------------------------------------------------------------------------------- 1 | include "arg_max.mzn"; 2 | 3 | predicate fzn_maximum_arg_bool_opt(array [int] of var opt bool: x, var int: z) = 4 | let { 5 | array [index_set(x)] of var 0..2: dx = 6 | array1d(index_set(x), [(xi + 1) default 0 | xi in x]); 7 | } in maximum_arg(dx, z); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_regular_nfa_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_regular_nfa_reif( 2 | array [int] of var int: x, 3 | int: Q, 4 | int: S, 5 | array [int, int] of set of int: d, 6 | int: q0, 7 | set of int: F, 8 | var bool: b, 9 | ) = abort("Reified regular_nfa constraint is not supported"); 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_060.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | w1 w2 w3 w4 5 | v1 v2 6 | n1 n2 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /editors/code/tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "module": "commonjs", 4 | "target": "es2020", 5 | "lib": ["es2020"], 6 | "outDir": "out", 7 | "rootDir": "src", 8 | "sourceMap": true 9 | }, 10 | "include": ["src"], 11 | "exclude": ["node_modules", ".vscode-test"] 12 | } 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_strict.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive_strict( 2 | array [int] of var int: s, 3 | array [int] of var int: d, 4 | ) = 5 | forall (i in index_set(d)) (d[i] >= 0) /\ 6 | forall (i, j in index_set(d) where i < j) ( 7 | s[i] + d[i] <= s[j] \/ s[j] + d[j] <= s[i] 8 | ); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_max_float_opt.mzn: -------------------------------------------------------------------------------- 1 | include "arg_max.mzn"; 2 | 3 | predicate fzn_maximum_arg_float_opt( 4 | array [int] of var opt float: x, 5 | var int: z, 6 | ) = 7 | let { 8 | float: def = lb_array(x) - 1; 9 | } in maximum_arg(array1d(index_set(x), [xi default def | xi in x]), z); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_min_float_opt.mzn: -------------------------------------------------------------------------------- 1 | include "arg_min.mzn"; 2 | 3 | predicate fzn_minimum_arg_float_opt( 4 | array [int] of var opt float: x, 5 | var int: z, 6 | ) = 7 | let { 8 | float: def = ub_array(x) + 1; 9 | } in minimum_arg(array1d(index_set(x), [xi default def | xi in x]), z); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_less_int.mzn: -------------------------------------------------------------------------------- 1 | include "lex_less.mzn"; 2 | 3 | predicate fzn_lex_chain_less_int(array [int, int] of var int: a) = 4 | let { 5 | int: lb2 = min(index_set_2of2(a)); 6 | int: ub2 = max(index_set_2of2(a)); 7 | } in forall (j in lb2 + 1..ub2) (lex_less(col(a, j - 1), col(a, j))); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_regular_nfa_set_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_regular_nfa_reif( 2 | array [int] of var int: x, 3 | int: Q, 4 | set of int: S, 5 | array [int, int] of set of int: d, 6 | int: q0, 7 | set of int: F, 8 | var bool: b, 9 | ) = abort("Reified regular_nfa constraint is not supported"); 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_062.xml: -------------------------------------------------------------------------------- 1 | 2 | y1 y2 y3 3 | 4 | (10,0,5,0) // costs for y1 5 | (0,5,0,0) // costs for y2 6 | (5,10,0,0) // costs for y3 7 | 8 | (le,12) 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_156.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1..3 4 | 5 | 6 | 7 | x[][] 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive( 2 | array [int] of var int: s, 3 | array [int] of var int: d, 4 | ) = 5 | forall (i in index_set(d)) (d[i] >= 0) /\ 6 | forall (i, j in index_set(d) where i < j) ( 7 | d[i] = 0 \/ d[j] = 0 \/ s[i] + d[i] <= s[j] \/ s[j] + d[j] <= s[i] 8 | ); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_less_bool.mzn: -------------------------------------------------------------------------------- 1 | include "lex_less.mzn"; 2 | 3 | predicate fzn_lex_chain_less_bool(array [int, int] of var bool: a) = 4 | let { 5 | int: lb2 = min(index_set_2of2(a)); 6 | int: ub2 = max(index_set_2of2(a)); 7 | } in forall (j in lb2 + 1..ub2) (lex_less(col(a, j - 1), col(a, j))); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_symmetric_all_different_reif.mzn: -------------------------------------------------------------------------------- 1 | include "all_different.mzn"; 2 | 3 | predicate fzn_symmetric_all_different_reif( 4 | array [int] of var int: x, 5 | var bool: b, 6 | ) = 7 | b <-> 8 | all_different(x) /\ 9 | forall (i, j in index_set(x) where i != j) (x[i] = j -> x[j] = i); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_write.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_write( 2 | array [int] of var int: I, 3 | var int: i, 4 | var int: v, 5 | array [int] of var int: O, 6 | ) = forall (j in index_set(I)) (O[j] = if j = i then v else I[j] endif); 7 | 8 | %-----------------------------------------------------------------------------% 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_075.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 x5 5 | 25 53 38 41 32 6 | (le,100) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_109.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 4 | 5 | 6 | v1 v2 v3 7 | w1 w2 w3 w4 8 | z1 z2 9 | {0,1} 10 | 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_lesseq_bool.mzn: -------------------------------------------------------------------------------- 1 | include "lex_lesseq.mzn"; 2 | 3 | predicate fzn_lex_chain_lesseq_bool(array [int, int] of var bool: a) = 4 | let { 5 | int: lb2 = min(index_set_2of2(a)); 6 | int: ub2 = max(index_set_2of2(a)); 7 | } in forall (j in lb2 + 1..ub2) (lex_lesseq(col(a, j - 1), col(a, j))); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_lesseq_int.mzn: -------------------------------------------------------------------------------- 1 | include "lex_lesseq.mzn"; 2 | 3 | predicate fzn_lex_chain_lesseq_int(array [int, int] of var int: a) = 4 | let { 5 | int: lb2 = min(index_set_2of2(a)); 6 | int: ub2 = max(index_set_2of2(a)); 7 | } in forall (j in lb2 + 1..ub2) (lex_lesseq(col(a, j - 1), col(a, j))); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_chain_set.mzn: -------------------------------------------------------------------------------- 1 | include "value_precede.mzn"; 2 | 3 | predicate fzn_value_precede_chain_set( 4 | array [int] of int: c, 5 | array [int] of var set of int: x, 6 | ) = 7 | forall (i in min(index_set(c)) + 1..max(index_set(c))) ( 8 | value_precede(c[i - 1], c[i], x) 9 | ); 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_076.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | y1 y2 y3 y4 y5 y6 y7 5 | 12 7 21 36 19 22 30 6 | l1 l2 l3 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_113.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 y4 4 | le 5 | 6 | 7 | z1 z2 z3 8 | z4 z5 z6 9 | z7 z8 z9 10 | gt 11 | 12 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_145.xml: -------------------------------------------------------------------------------- 1 | 2 | eq(w,add(x,y)) 3 | 4 | v w 5 | (0,1)(1,3)(1,2)(1,3)(2,0)(2,2)(3,1) 6 | 7 | v w x y 8 | z 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_035.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | eq(add(x,y),z) 5 | 6 | 7 | ge(w,z) 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_126.xml: -------------------------------------------------------------------------------- 1 | 2 | y1 y2 y3 3 | 4 | (10,0,5) // costs for y1 5 | (0,5,0) // costs for y2 6 | (5,10,0) // costs for y3 7 | 8 | (eq,z) 9 | 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_eq_par_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_eq_reif.mzn"; 2 | 3 | predicate fzn_count_eq_par_reif( 4 | array [int] of var int: x, 5 | int: y, 6 | int: c, 7 | var bool: b, 8 | ) = fzn_count_eq_reif(x, y, c, b); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_gt_par_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_gt_reif.mzn"; 2 | 3 | predicate fzn_count_gt_par_reif( 4 | array [int] of var int: x, 5 | int: y, 6 | int: c, 7 | var bool: b, 8 | ) = fzn_count_gt_reif(x, y, c, b); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_lt_par_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_lt_reif.mzn"; 2 | 3 | predicate fzn_count_lt_par_reif( 4 | array [int] of var int: x, 5 | int: y, 6 | int: c, 7 | var bool: b, 8 | ) = fzn_count_lt_reif(x, y, c, b); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_set_member.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_set_member(var set of int: x, var int: y) = y in x; 6 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_cost_regular_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_cost_regular_reif( 2 | array [int] of var int: x, 3 | int: Q, 4 | int: S, 5 | array [int, int] of int: d, 6 | int: q0, 7 | set of int: F, 8 | array [int, int] of int: c, 9 | var int: C, 10 | var bool: b, 11 | ) = abort("Reified cost_regular is not supported."); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_geq_par_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_geq_reif.mzn"; 2 | 3 | predicate fzn_count_geq_par_reif( 4 | array [int] of var int: x, 5 | int: y, 6 | int: c, 7 | var bool: b, 8 | ) = fzn_count_geq_reif(x, y, c, b); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_leq_par_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_leq_reif.mzn"; 2 | 3 | predicate fzn_count_leq_par_reif( 4 | array [int] of var int: x, 5 | int: y, 6 | int: c, 7 | var bool: b, 8 | ) = fzn_count_leq_reif(x, y, c, b); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_neq_par_reif.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_count_neq_reif.mzn"; 2 | 3 | predicate fzn_count_neq_par_reif( 4 | array [int] of var int: x, 5 | int: y, 6 | int: c, 7 | var bool: b, 8 | ) = fzn_count_neq_reif(x, y, c, b); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_sum_pred.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_sum_pred( 2 | var int: i, 3 | array [int] of set of int: sets, 4 | array [int] of int: cs, 5 | var int: s, 6 | ) = 7 | let { 8 | array [index_set(sets)] of int: sums = [ 9 | sum (k in sets[j]) (cs[k]) | 10 | j in index_set(sets), 11 | ]; 12 | } in sums[i] = s; 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_int_opt.mzn: -------------------------------------------------------------------------------- 1 | include "value_precede.mzn"; 2 | 3 | predicate fzn_value_precede_int_opt( 4 | int: s, 5 | int: t, 6 | array [int] of var opt int: x, 7 | ) = 8 | let { 9 | int: def = if had_zero(x) then max(s, t) + 1 else 0 endif; 10 | } in value_precede(s, t, [y default def | y in x]); 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_044.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 x5 5 | 6 | 7 | y[] 8 | 0 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /share/minizinc/std/all_disjoint.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_all_disjoint.mzn"; 2 | include "fzn_all_disjoint_reif.mzn"; 3 | 4 | /** @group globals.alldifferent 5 | Constrain the array of sets of integers \a S to be pairwise disjoint. 6 | */ 7 | predicate all_disjoint(array [$X] of var set of $$E: S) = 8 | fzn_all_disjoint(erase_enum(array1d(S))); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_distribute_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_distribute_reif( 2 | array [int] of var int: card, 3 | array [int] of var int: value, 4 | array [int] of var int: base, 5 | var bool: b, 6 | ) = 7 | b <-> 8 | forall (i in index_set(card)) ( 9 | card[i] == sum (j in index_set(base)) (value[i] = base[j]) 10 | ); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/nvalue_fn.mzn: -------------------------------------------------------------------------------- 1 | include "nvalue.mzn"; 2 | 3 | /** @group globals.alldifferent 4 | Returns the number of distinct values in \a x. 5 | */ 6 | function var int: nvalue(array [$X] of var int: x) = 7 | let { 8 | var 0..length(x): n :: is_defined_var; 9 | constraint nvalue(n, x) :: defines_var(n); 10 | } in n; 11 | -------------------------------------------------------------------------------- /crates/shackle-compiler/src/hir/lower/eprime/mod.rs: -------------------------------------------------------------------------------- 1 | //! Functionality for converting AST nodes to HIR nodes 2 | //! 3 | //! The AST is lowered to HIR by performing the following syntactic desugarings: 4 | //! 5 | 6 | mod expression; 7 | mod item; 8 | 9 | pub use self::{expression::*, item::*}; 10 | 11 | #[cfg(test)] 12 | mod test; 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_077.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | y1 y2 y3 y4 y5 y6 y7 5 | 12 7 21 36 19 22 30 6 | (le,20)(eq,8)(lt,l) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_108.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 y4 4 | 5 | 6 | v1 v2 v3 v4 7 | w1 w2 w3 w4 8 | z1 z2 z3 z4 9 | (0,0,0,0) 10 | 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_119.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | (x1,x2,x3,x4) 4 | (y1,y2,y3,y4) 5 | (z1,z2,z3,z4) 6 | 7 | 0 1 8 | (r10,r11)(r20,r21)(r30,r31) 9 | (c10,c11)(c20,c21)(c30,c31)(c40,c41) 10 | 11 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/node/binding_test.js: -------------------------------------------------------------------------------- 1 | const assert = require("node:assert"); 2 | const { test } = require("node:test"); 3 | 4 | const Parser = require("tree-sitter"); 5 | 6 | test("can load grammar", () => { 7 | const parser = new Parser(); 8 | assert.doesNotThrow(() => parser.setLanguage(require("."))); 9 | }); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_sort_int.mzn: -------------------------------------------------------------------------------- 1 | include "all_different.mzn"; 2 | 3 | predicate fzn_arg_sort_int( 4 | array [int] of var int: x, 5 | array [int] of var int: p, 6 | ) = 7 | all_different(p) /\ 8 | forall (j in 1..length(x) - 1) ( 9 | x[p[j]] <= x[p[j + 1]] /\ 10 | (x[p[j]] == x[p[j + 1]] -> p[j] < p[j + 1]) 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_regular_set.mzn.deprecated.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_regular( 2 | array [int] of var int: x, 3 | int: Q, 4 | set of int: S, 5 | array [int, int] of int: d, 6 | int: q0, 7 | set of int: F, 8 | ) 9 | :: mzn_deprecated( 10 | "2.6.0", 11 | "https://www.minizinc.org/doc-2.6.0/en/lib-globals.html#deprecated", 12 | ); 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_110.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 y4 4 | 5 | 6 | v1 v2 v3 v4 7 | w1 w2 w3 w4 8 | z1 z2 z3 z4 9 | {{0,0,0,0}} 10 | 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_112.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 y4 4 | z1 z2 z3 5 | 6 | 7 | v1 v2 v3 8 | v4 v5 v6 v7 9 | v8 v9 10 | 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_134.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | x0 x1 x2 4 | 0 2 4 5 | (in,0..1) 6 | 7 | 8 | x2 x3 x4 9 | 0 2 4 10 | (in,1..2) 11 | 12 | 13 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/node/binding_test.js: -------------------------------------------------------------------------------- 1 | const assert = require("node:assert"); 2 | const { test } = require("node:test"); 3 | 4 | const Parser = require("tree-sitter"); 5 | 6 | test("can load grammar", () => { 7 | const parser = new Parser(); 8 | assert.doesNotThrow(() => parser.setLanguage(require("."))); 9 | }); 10 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/node/binding_test.js: -------------------------------------------------------------------------------- 1 | const assert = require("node:assert"); 2 | const { test } = require("node:test"); 3 | 4 | const Parser = require("tree-sitter"); 5 | 6 | test("can load grammar", () => { 7 | const parser = new Parser(); 8 | assert.doesNotThrow(() => parser.setLanguage(require("."))); 9 | }); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_alternative_reif.mzn: -------------------------------------------------------------------------------- 1 | include "span.mzn"; 2 | 3 | predicate fzn_alternative_reif( 4 | var opt int: s0, 5 | var int: d0, 6 | array [int] of var opt int: s, 7 | array [int] of var int: d, 8 | var bool: b, 9 | ) = 10 | b <-> 11 | sum (i in index_set(s)) (occurs(s[i])) = occurs(s0) /\ 12 | span(s0, d0, s, d); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_sort_float.mzn: -------------------------------------------------------------------------------- 1 | include "all_different.mzn"; 2 | 3 | predicate fzn_arg_sort_float( 4 | array [int] of var float: x, 5 | array [int] of var int: p, 6 | ) = 7 | all_different(p) /\ 8 | forall (j in 1..length(x) - 1) ( 9 | x[p[j]] <= x[p[j + 1]] /\ 10 | (x[p[j]] == x[p[j + 1]] -> p[j] < p[j + 1]) 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_geost_nonoverlap_k.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_geost_nonoverlap_k( 2 | array [int] of var int: x1, 3 | array [int] of int: w1, 4 | array [int] of var int: x2, 5 | array [int] of int: w2, 6 | ) = 7 | % Non-overlap constraint 8 | exists (j in index_set(x1)) ( 9 | x1[j] + w1[j] <= x2[j] \/ x2[j] + w2[j] <= x1[j] 10 | ); 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_125.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 y4 4 | 5 | 6 | v1 v2 v3 7 | v4 v5 v6 8 | m1 m2 m3 9 | 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality.mzn: -------------------------------------------------------------------------------- 1 | include "count.mzn"; 2 | 3 | predicate fzn_global_cardinality( 4 | array [int] of var int: x, 5 | array [int] of int: cover, 6 | array [int] of var int: counts, 7 | ) = 8 | forall (i in index_set(cover)) (count(x, cover[i], counts[i])) /\ 9 | % Implied constraint 10 | length(x) >= sum(counts); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex2.mzn: -------------------------------------------------------------------------------- 1 | include "lex_chain_lesseq.mzn"; 2 | 3 | predicate fzn_lex2(array [int, int] of var int: x) = 4 | lex_chain_lesseq(x) /\ 5 | lex_chain_lesseq( %% transpose 6 | array2d( 7 | index_set_2of2(x), 8 | index_set_1of2(x), 9 | [x[i, j] | j in index_set_2of2(x), i in index_set_1of2(x)], 10 | ), 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_roots.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_roots( 2 | array [int] of var int: x, 3 | var set of int: s, 4 | var set of int: t, 5 | ) = 6 | % All values in 's' must map to a value in 't'. 7 | forall (i in ub(s)) (i in s -> x[i] in t) /\ 8 | forall (i in ub(t)) ( 9 | i in t -> forall (j in index_set(x)) (x[j] = i -> j in s) 10 | ); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/lex2.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_lex2.mzn"; 2 | include "fzn_lex2_reif.mzn"; 3 | 4 | /** @group globals.lexicographic 5 | Require adjacent rows and adjacent columns in the array \a x to be 6 | lexicographically ordered. Adjacent rows and adjacent columns may be equal. 7 | */ 8 | predicate lex2(array [int, int] of var int: x) = fzn_lex2(x); 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_074.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | s0 s1 s2 s3 s4 5 | 3 2 5 4 2 6 | 1 2 1 1 3 7 | (le,4) 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_array_int_union.mzn: -------------------------------------------------------------------------------- 1 | /* Constrain y to be the set of the elements in x */ 2 | predicate fzn_array_int_union(array [int] of var int: x, var set of int: y) = 3 | y = 4 | array_union([ 5 | let { 6 | var set of dom(x[i]): s; 7 | constraint x[i] in s /\ card(s) = 1; 8 | } in s | 9 | i in index_set(x), 10 | ]); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_strict_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive_strict_reif( 2 | array [int] of var int: s, 3 | array [int] of var int: d, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i in index_set(d)) (d[i] >= 0) /\ 8 | forall (i, j in index_set(d) where i < j) ( 9 | s[i] + d[i] <= s[j] \/ s[j] + d[j] <= s[i] 10 | ); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_closed.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_closed( 4 | array [int] of var int: x, 5 | array [int] of int: cover, 6 | array [int] of var int: counts, 7 | ) = 8 | forall (i in index_set(x)) (x[i] in {d | d in cover}) /\ 9 | global_cardinality(x, cover, counts); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_write_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_write_reif( 2 | array [int] of var int: I, 3 | var int: i, 4 | var int: v, 5 | array [int] of var int: O, 6 | var bool: b, 7 | ) = b <-> forall (j in index_set(I)) (O[j] = if j = i then v else I[j] endif); 8 | 9 | %-----------------------------------------------------------------------------% 10 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_017.xml: -------------------------------------------------------------------------------- 1 | 1..100 2 | 0 1 3 | 4 | 1..6:1/6 5 | 6 | 7 | a b 8 | c d 9 | 10 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/python/tree_sitter_eprime/__init__.pyi: -------------------------------------------------------------------------------- 1 | from typing import Final 2 | 3 | # NOTE: uncomment these to include any queries that this grammar contains: 4 | 5 | # HIGHLIGHTS_QUERY: Final[str] 6 | # INJECTIONS_QUERY: Final[str] 7 | # LOCALS_QUERY: Final[str] 8 | # TAGS_QUERY: Final[str] 9 | 10 | def language() -> object: ... 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_closed_set.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_closed_set( 4 | array [int] of var set of int: x, 5 | array [int] of int: cover, 6 | array [int] of var int: counts, 7 | ) = 8 | global_cardinality(x, cover, counts) /\ 9 | forall (v in x) (v subset {d | d in cover}); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_set_member_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_set_member_reif(var set of int: x, var int: y, var bool: b) = 6 | b <-> y in x; 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_span.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_span( 2 | var opt int: s0, 3 | var int: d0, 4 | array [int] of var opt int: s, 5 | array [int] of var int: d, 6 | ) = 7 | (occurs(s0) <-> exists (i in index_set(s)) (occurs(s[i]))) /\ 8 | s0 = min_weak(s) /\ 9 | (absent(s0) -> d0 = 0) /\ 10 | s0 ~+ d0 = max_weak([s[i] ~+ d[i] | i in index_set(s)]); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strict_lex2.mzn: -------------------------------------------------------------------------------- 1 | include "lex_chain_less.mzn"; 2 | 3 | predicate fzn_strict_lex2(array [int, int] of var int: x) = 4 | lex_chain_less(x) /\ 5 | lex_chain_less( %% transpose 6 | array2d( 7 | index_set_2of2(x), 8 | index_set_1of2(x), 9 | [x[i, j] | j in index_set_2of2(x), i in index_set_1of2(x)], 10 | ), 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/partition_set.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_partition_set.mzn"; 2 | include "fzn_partition_set_reif.mzn"; 3 | 4 | /** @group globals.set 5 | Constrains the sets in array \a S to partition the \a universe. 6 | */ 7 | predicate partition_set(array [_] of var set of $$E: S, set of $$E: universe) = 8 | fzn_partition_set(erase_enum(S), erase_enum(universe)); 9 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/python/tree_sitter_datazinc/__init__.pyi: -------------------------------------------------------------------------------- 1 | from typing import Final 2 | 3 | # NOTE: uncomment these to include any queries that this grammar contains: 4 | 5 | # HIGHLIGHTS_QUERY: Final[str] 6 | # INJECTIONS_QUERY: Final[str] 7 | # LOCALS_QUERY: Final[str] 8 | # TAGS_QUERY: Final[str] 9 | 10 | def language() -> object: ... 11 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/python/tree_sitter_minizinc/__init__.pyi: -------------------------------------------------------------------------------- 1 | from typing import Final 2 | 3 | # NOTE: uncomment these to include any queries that this grammar contains: 4 | 5 | # HIGHLIGHTS_QUERY: Final[str] 6 | # INJECTIONS_QUERY: Final[str] 7 | # LOCALS_QUERY: Final[str] 8 | # TAGS_QUERY: Final[str] 9 | 10 | def language() -> object: ... 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_connected_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_connected_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | array [int] of var bool: ns, 5 | array [int] of var bool: es, 6 | var bool: b, 7 | ) = abort("Reified connected is not supported."); 8 | 9 | %-----------------------------------------------------------------------------% 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dconnected_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_dconnected_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | array [int] of var bool: ns, 5 | array [int] of var bool: es, 6 | var bool: b, 7 | ) = abort("Reified dconnected is not supported."); 8 | 9 | %-----------------------------------------------------------------------------% 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_less_bool_reif.mzn: -------------------------------------------------------------------------------- 1 | include "lex_less.mzn"; 2 | 3 | predicate fzn_lex_chain_less_bool_reif( 4 | array [int, int] of var bool: a, 5 | var bool: b, 6 | ) = 7 | let { 8 | int: lb2 = min(index_set_2of2(a)); 9 | int: ub2 = max(index_set_2of2(a)); 10 | } in b <-> forall (j in lb2 + 1..ub2) (lex_less(col(a, j - 1), col(a, j))); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_less_int_reif.mzn: -------------------------------------------------------------------------------- 1 | include "lex_less.mzn"; 2 | 3 | predicate fzn_lex_chain_less_int_reif( 4 | array [int, int] of var int: a, 5 | var bool: b, 6 | ) = 7 | let { 8 | int: lb2 = min(index_set_2of2(a)); 9 | int: ub2 = max(index_set_2of2(a)); 10 | } in b <-> forall (j in lb2 + 1..ub2) (lex_less(col(a, j - 1), col(a, j))); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_piecewise_linear_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_piecewise_linear_reif( 2 | var float: x, 3 | var float: y, 4 | array [int] of float: xi, 5 | array [int] of float: vi, 6 | var bool: b, 7 | ) = abort("Reified piecewise_linear constraint is not supported"); 8 | 9 | %-----------------------------------------------------------------------------% 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_sum_pred_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_sum_pred_reif( 2 | var int: i, 3 | array [int] of set of int: sets, 4 | array [int] of int: cs, 5 | var int: s, 6 | var bool: b, 7 | ) = 8 | let { 9 | array [index_set(sets)] of int: sums = [ 10 | sum (k in sets[j]) (cs[k]) | 11 | j in index_set(sets), 12 | ]; 13 | } in b <-> sums[i] = s; 14 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_043.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 5 | 6 | (r,0,n1)(r,1,n2)(r,2,n3) 7 | (n1,2,n4)(n2,2,n4)(n3,0,n5) 8 | (n4,0,t)(n5,0,t) 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_inverse_opt.mzn: -------------------------------------------------------------------------------- 1 | include "all_different.mzn"; 2 | 3 | predicate fzn_inverse_opt( 4 | array [int] of var opt int: f, 5 | array [int] of var opt int: invf, 6 | ) = 7 | all_different(f) /\ 8 | all_different(invf) /\ 9 | forall (i in index_set(f)) (invf[f[i]] = i) /\ 10 | forall (j in index_set(invf)) (occurs(invf[j]) <-> f[invf[j]] = j); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_lesseq_int_reif.mzn: -------------------------------------------------------------------------------- 1 | include "lex_lesseq.mzn"; 2 | 3 | predicate fzn_lex_chain_lesseq_int_reif( 4 | array [int, int] of var int: a, 5 | var bool: b, 6 | ) = 7 | let { 8 | int: lb2 = min(index_set_2of2(a)); 9 | int: ub2 = max(index_set_2of2(a)); 10 | } in b <-> forall (j in lb2 + 1..ub2) (lex_lesseq(col(a, j - 1), col(a, j))); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_int.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_int(array [int] of var int: x, var int: y) = 6 | exists (i in index_set(x)) (x[i] == y); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_wst_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_wst_reif( 2 | set of int: NODE, 3 | array [int] of int: from, 4 | array [int] of int: to, 5 | array [int] of int: w, 6 | array [int] of var bool: es, 7 | var int: K, 8 | ) = abort("Reified wst constraint is not supported"); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_135.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | x1 x2 x3 x4 x5 4 | 0 2 4 5 | (in,0..1) 6 | 7 | 8 | 9 | 0 1 10 | 0..2 2..3 11 | 12 | 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_max_int_opt.mzn: -------------------------------------------------------------------------------- 1 | include "arg_max.mzn"; 2 | 3 | predicate fzn_maximum_arg_int_opt(array [int] of var opt int: x, var int: z) = 4 | let { 5 | int: def = 6 | if not had_zero(x) /\ lb_array(x) > 0 then 7 | 0 8 | else 9 | lb_array(x) - 1 10 | endif; 11 | } in maximum_arg(array1d(index_set(x), [xi default def | xi in x]), z); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_min_int_opt.mzn: -------------------------------------------------------------------------------- 1 | include "arg_min.mzn"; 2 | 3 | predicate fzn_minimum_arg_int_opt(array [int] of var opt int: x, var int: z) = 4 | let { 5 | int: def = 6 | if not had_zero(x) /\ ub_array(x) < 0 then 7 | 0 8 | else 9 | ub_array(x) + 1 10 | endif; 11 | } in minimum_arg(array1d(index_set(x), [xi default def | xi in x]), z); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_closed_opt.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_closed_opt( 4 | array [int] of var opt int: x, 5 | array [int] of int: cover, 6 | array [int] of var int: counts, 7 | ) = 8 | forall (xi in x) (absent(xi) \/ deopt(xi) in {d | d in cover}) /\ 9 | global_cardinality(x, cover, counts); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_inverse_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_inverse_reif( 2 | array [int] of var int: f, 3 | array [int] of var int: invf, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i in index_set(f)) ( 8 | f[i] in index_set(invf) /\ invf[f[i]] == i 9 | ) /\ 10 | forall (j in index_set(invf)) ( 11 | invf[j] in index_set(f) /\ f[invf[j]] == j 12 | ); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_knapsack.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_knapsack( 2 | array [int] of int: w, 3 | array [int] of int: p, 4 | array [int] of var int: x, 5 | var int: W, 6 | var int: P, 7 | ) = 8 | forall (i in index_set(x)) (x[i] >= 0) /\ 9 | W >= 0 /\ 10 | P >= 0 /\ 11 | P = sum (i in index_set(p)) (x[i] * p[i]) /\ 12 | W = sum (i in index_set(w)) (x[i] * w[i]); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex_chain_lesseq_bool_reif.mzn: -------------------------------------------------------------------------------- 1 | include "lex_lesseq.mzn"; 2 | 3 | predicate fzn_lex_chain_lesseq_bool_reif( 4 | array [int, int] of var bool: a, 5 | var bool: b, 6 | ) = 7 | let { 8 | int: lb2 = min(index_set_2of2(a)); 9 | int: ub2 = max(index_set_2of2(a)); 10 | } in b <-> forall (j in lb2 + 1..ub2) (lex_lesseq(col(a, j - 1), col(a, j))); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_bool.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_bool(array [int] of var bool: x, var bool: y) = 6 | exists (i in index_set(x)) (x[i] == y); 7 | -------------------------------------------------------------------------------- /crates/flatzinc-serde/corpus/encapsulated_string.fzn.json: -------------------------------------------------------------------------------- 1 | { 2 | "variables": {}, 3 | "arrays": {}, 4 | "constraints": [], 5 | "output": [], 6 | "solve": { 7 | "method": "satisfy", 8 | "ann": [ 9 | { 10 | "id": "myAnn", 11 | "args": [ 12 | { 13 | "string": "my string" 14 | } 15 | ] 16 | } 17 | ] 18 | }, 19 | "verson": "1.0" 20 | } 21 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_030.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 x5 5 | 2 4 1 4 8 6 | 7 | 8 | y1 y2 y3 y4 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_085.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x y z 5 | 12 4 30 6 | 7 | 8 | w[] 9 | 1 0 2 1 3 1 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_opt.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive_opt( 2 | array [int] of var opt int: s, 3 | array [int] of var int: d, 4 | ) = 5 | forall (i, j in index_set(d) where i < j) ( 6 | absent(s[i]) \/ 7 | absent(s[j]) \/ 8 | d[i] = 0 \/ 9 | d[j] = 0 \/ 10 | deopt(s[i]) + d[i] <= deopt(s[j]) \/ 11 | deopt(s[j]) + d[j] <= deopt(s[i]) 12 | ); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dtree_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_dtree_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | var int: r, 5 | array [int] of var bool: ns, 6 | array [int] of var bool: es, 7 | var bool: b, 8 | ) = abort("Reified dtree constraint is not supported"); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_float.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_float(array [int] of var float: x, var float: y) = 6 | exists (i in index_set(x)) (x[i] == y); 7 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/c/tree_sitter/tree-sitter-eprime.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_SITTER_EPRIME_H_ 2 | #define TREE_SITTER_EPRIME_H_ 3 | 4 | typedef struct TSLanguage TSLanguage; 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | const TSLanguage *tree_sitter_eprime(void); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | #endif // TREE_SITTER_EPRIME_H_ 17 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/swift/TreeSitterEprime/eprime.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_SITTER_EPRIME_H_ 2 | #define TREE_SITTER_EPRIME_H_ 3 | 4 | typedef struct TSLanguage TSLanguage; 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | const TSLanguage *tree_sitter_eprime(void); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | #endif // TREE_SITTER_EPRIME_H_ 17 | -------------------------------------------------------------------------------- /share/minizinc/std/among.mzn: -------------------------------------------------------------------------------- 1 | include "among_fn.mzn"; 2 | 3 | include "fzn_among.mzn"; 4 | include "fzn_among_reif.mzn"; 5 | 6 | /** @group globals.counting 7 | Requires exactly \a n variables in \a x to take one of the values in \a v. 8 | */ 9 | predicate among(var int: n, array [$X] of var $$E: x, set of $$E: v) = 10 | fzn_among(n, erase_enum(array1d(x)), erase_enum(v)); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_equal_int.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all equal. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_equal_int(array [int] of var int: x) = 6 | forall (i, j in index_set(x) where i < j) (x[i] = x[j]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_sort_int_reif.mzn: -------------------------------------------------------------------------------- 1 | include "all_different.mzn"; 2 | 3 | predicate fzn_arg_sort_int_reif( 4 | array [int] of var int: x, 5 | array [int] of var int: p, 6 | var bool: b, 7 | ) = 8 | b <-> 9 | all_different(p) /\ 10 | forall (j in 1..length(x) - 1) ( 11 | x[p[j]] <= x[p[j + 1]] /\ 12 | (x[p[j]] == x[p[j + 1]] -> p[j] < p[j + 1]) 13 | ); 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_circuit_opt.mzn: -------------------------------------------------------------------------------- 1 | include "subcircuit.mzn"; 2 | 3 | predicate fzn_circuit_opt(array [int] of var opt int: x) = 4 | subcircuit( 5 | array1d( 6 | index_set(x), 7 | [ 8 | if occurs(x[i]) then deopt(x[i]) else i endif | 9 | i in index_set(x), 10 | ], 11 | ), 12 | ) /\ 13 | forall (i in index_set(x)) (occurs(x[i]) -> deopt(x[i]) != i); 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_geost_nonoverlap_k_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_geost_nonoverlap_k_reif( 2 | array [int] of var int: x1, 3 | array [int] of int: w1, 4 | array [int] of var int: x2, 5 | array [int] of int: w2, 6 | var bool: b, 7 | ) = 8 | % Non-overlap constraint 9 | b <-> 10 | exists (j in index_set(x1)) ( 11 | x1[j] + w1[j] <= x2[j] \/ x2[j] + w2[j] <= x1[j] 12 | ); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array of set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_set(array [int] of var set of int: x, var set of int: y) = 6 | exists (i in index_set(x)) (x[i] == y); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_subgraph.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_subgraph( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | array [int] of var bool: ns, 5 | array [int] of var bool: es, 6 | ) = 7 | forall (e in index_set(from)) ( 8 | (es[e] -> ns[from[e]]) /\ (es[e] -> ns[to[e]]) 9 | ); 10 | 11 | %-----------------------------------------------------------------------------% 12 | -------------------------------------------------------------------------------- /share/minizinc/std/lex2_strict.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_strict_lex2.mzn"; 2 | include "fzn_strict_lex2_reif.mzn"; 3 | 4 | /** @group globals.lexicographic 5 | Require adjacent rows and adjacent columns in the array \a x to be 6 | lexicographically ordered. Adjacent rows and adjacent columns cannot be equal. 7 | */ 8 | predicate lex2_strict(array [int, int] of var int: x) = fzn_strict_lex2(x); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/strict_lex2.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_strict_lex2.mzn"; 2 | include "fzn_strict_lex2_reif.mzn"; 3 | 4 | /** @group globals.lexicographic 5 | Requires adjacent rows and adjacent columns in the array \a x to be 6 | lexicographically ordered. Adjacent rows and adjacent columns cannot be equal. 7 | */ 8 | predicate strict_lex2(array [int, int] of var int: x) = fzn_strict_lex2(x); 9 | -------------------------------------------------------------------------------- /crates/shackle-compiler/src/thir/ir/traverse/mod.rs: -------------------------------------------------------------------------------- 1 | //! Utilities for traversing THIR trees. 2 | //! 3 | //! The `Folder` trait is used to create a modified copy of the model (i.e. a tree-to-tree transformation). 4 | //! The `Visitor` trait is used to visit a model recursively (without copying it). 5 | //! 6 | 7 | mod fold; 8 | mod visit; 9 | 10 | pub use self::{fold::*, visit::*}; 11 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_111.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | y1 y2 y3 y4 4 | z1 z2 z3 5 | (gt,0) 6 | 7 | 8 | v1 v2 v3 9 | v4 v5 v6 v7 10 | v8 v9 11 | (eq,0) 12 | 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_179.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | [-4,4] 4 | [-4,4] 5 | 6 | 7 | eq(sub(y,pow(x,2)),0) 8 | eq(sub(y,add(x,1)),0) 9 | 10 | 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_equal_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all equal. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_equal_set(array [int] of var set of int: x) = 6 | forall (i, j in index_set(x) where i < j) (x[i] = x[j]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_sort_float_reif.mzn: -------------------------------------------------------------------------------- 1 | include "all_different.mzn"; 2 | 3 | predicate fzn_arg_sort_float_reif( 4 | array [int] of var float: x, 5 | array [int] of var int: p, 6 | var bool: b, 7 | ) = 8 | b <-> 9 | all_different(p) /\ 10 | forall (j in 1..length(x) - 1) ( 11 | x[p[j]] <= x[p[j + 1]] /\ 12 | (x[p[j]] == x[p[j + 1]] -> p[j] < p[j + 1]) 13 | ); 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_connected.mzn: -------------------------------------------------------------------------------- 1 | include "reachable.mzn"; 2 | 3 | predicate fzn_connected( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of var bool: ns, 7 | array [int] of var bool: es, 8 | ) = let { var index_set(ns): r } in reachable(from, to, r, ns, es); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dconnected.mzn: -------------------------------------------------------------------------------- 1 | include "reachable.mzn"; 2 | 3 | predicate fzn_dconnected( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of var bool: ns, 7 | array [int] of var bool: es, 8 | ) = let { var index_set(ns): r } in dreachable(from, to, r, ns, es); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_inverse_in_range_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_inverse_in_range_reif( 2 | array [int] of var int: f, 3 | array [int] of var int: invf, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i in index_set(f)) ( 8 | f[i] in index_set(invf) -> invf[f[i]] == i 9 | ) /\ 10 | forall (j in index_set(invf)) ( 11 | invf[j] in index_set(f) -> f[invf[j]] == j 12 | ); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_inverse_set.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_inverse_set( 2 | array [int] of var set of int: f, 3 | array [int] of var set of int: invf, 4 | ) = 5 | forall (i in index_set(f)) (f[i] subset index_set(invf)) /\ 6 | forall (j in index_set(invf)) (invf[j] subset index_set(f)) /\ 7 | forall (i in index_set(f), j in index_set(invf)) ( 8 | j in f[i] <-> i in invf[j] 9 | ); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_lex2_reif.mzn: -------------------------------------------------------------------------------- 1 | include "lex_lesseq.mzn"; 2 | 3 | predicate fzn_lex2_reif(array [int, int] of var int: x, var bool: b) = 4 | b <-> 5 | lex_chain_lesseq(x) /\ 6 | lex_chain_lesseq( %% transpose 7 | array2d( 8 | index_set_2of2(x), 9 | index_set_1of2(x), 10 | [x[i, j] | j in index_set_2of2(x), i in index_set_1of2(x)], 11 | ), 12 | ); 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_041.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 x5 x6 x7 5 | 6 | (a,0,a)(a,1,b)(b,1,c)(c,0,d)(d,0,d)(d,1,e)(e,0,e) 7 | 8 | a 9 | e 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_063.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 5 | (eq,y) 6 | 7 | 8 | z1 z2 z3 z4 z5 9 | (lt,w) 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_064.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 5 | (eq,y) 6 | 7 | 8 | z1 z2 z3 z4 z5 9 | (ne,w) 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/swift/TreeSitterDatazinc/datazinc.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_SITTER_DATAZINC_H_ 2 | #define TREE_SITTER_DATAZINC_H_ 3 | 4 | typedef struct TSLanguage TSLanguage; 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | const TSLanguage *tree_sitter_datazinc(void); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | #endif // TREE_SITTER_DATAZINC_H_ 17 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/swift/TreeSitterMinizinc/minizinc.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_SITTER_MINIZINC_H_ 2 | #define TREE_SITTER_MINIZINC_H_ 3 | 4 | typedef struct TSLanguage TSLanguage; 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | const TSLanguage *tree_sitter_minizinc(void); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | #endif // TREE_SITTER_MINIZINC_H_ 17 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_different_int.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all different. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_different_int(array [int] of var int: x) = 6 | forall (i, j in index_set(x) where i < j) (x[i] != x[j]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_bounded_path.mzn: -------------------------------------------------------------------------------- 1 | include "path.mzn"; 2 | 3 | predicate fzn_bounded_path( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of int: w, 7 | var int: s, 8 | var int: t, 9 | array [int] of var bool: ns, 10 | array [int] of var bool: es, 11 | var int: K, 12 | ) = path(from, to, s, t, ns, es) /\ K = sum (e in index_set(es)) (es[e] * w[e]); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive_reif( 2 | array [int] of var int: s, 3 | array [int] of var int: d, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i in index_set(d)) (d[i] >= 0) /\ 8 | forall (i, j in index_set(d) where i < j) ( 9 | d[i] = 0 \/ 10 | d[j] = 0 \/ 11 | s[i] + d[i] <= s[j] \/ 12 | s[j] + d[j] <= s[i] 13 | ); 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dpath_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_dpath_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | var int: s, 5 | var int: t, 6 | array [int] of var bool: ns, 7 | array [int] of var bool: es, 8 | var bool: b, 9 | ) = abort("Reified dpath constraint is not supported"); 10 | 11 | %-----------------------------------------------------------------------------% 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dreachable_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_dreachable_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | var int: r, 5 | array [int] of var bool: ns, 6 | array [int] of var bool: es, 7 | var bool: b, 8 | ) = abort("Reified dreachable constraint is not supported"); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_closed_reif.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_closed_reif( 4 | array [int] of var int: x, 5 | array [int] of int: cover, 6 | array [int] of var int: counts, 7 | var bool: b, 8 | ) = 9 | b <-> 10 | forall (i in index_set(x)) (x[i] in {d | d in cover}) /\ 11 | global_cardinality(x, cover, counts); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count.mzn"; 2 | 3 | predicate fzn_global_cardinality_reif( 4 | array [int] of var int: x, 5 | array [int] of int: cover, 6 | array [int] of var int: counts, 7 | var bool: b, 8 | ) = 9 | b <-> 10 | forall (i in index_set(cover)) (count(x, cover[i], counts[i])) /\ 11 | % Implied constraint 12 | length(x) >= sum(counts); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_roots_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_roots_reif( 2 | array [int] of var int: x, 3 | var set of int: s, 4 | var set of int: t, 5 | var bool: b, 6 | ) = 7 | b <-> 8 | % All values in 's' must map to a value in 't'. 9 | forall (i in ub(s)) (i in s -> x[i] in t) /\ 10 | forall (i in ub(t)) ( 11 | i in t -> forall (j in index_set(x)) (x[j] = i -> j in s) 12 | ); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_span_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_span_reif( 2 | var opt int: s0, 3 | var int: d0, 4 | array [int] of var opt int: s, 5 | array [int] of var int: d, 6 | var bool: b, 7 | ) = 8 | b <-> 9 | (occurs(s0) <-> exists (i in index_set(s)) (occurs(s[i]))) /\ 10 | s0 = min(s) /\ 11 | (absent(s0) -> d0 = 0) /\ 12 | s0 ~+ d0 = max([s[i] ~+ d[i] | i in index_set(s)]); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/roots_fn.mzn: -------------------------------------------------------------------------------- 1 | include "roots.mzn"; 2 | 3 | /** @group globals.set 4 | Returns \a s such that \a x[\p i] in \a t for all \p i in \a s 5 | */ 6 | function var set of $$X: roots(array [$$X] of var $$Y: x, var set of $$Y: t) 7 | :: promise_total = 8 | let { 9 | var set of index_set(x): s :: is_defined_var; 10 | constraint roots(x, s, t) :: defines_var(s); 11 | } in s; 12 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_100.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | s1 s2 s3 6 | i 7 | t 8 | 9 | 10 | t1 t2 t3 t4 11 | t5 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/c/tree_sitter/tree-sitter-datazinc.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_SITTER_DATAZINC_H_ 2 | #define TREE_SITTER_DATAZINC_H_ 3 | 4 | typedef struct TSLanguage TSLanguage; 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | const TSLanguage *tree_sitter_datazinc(void); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | #endif // TREE_SITTER_DATAZINC_H_ 17 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/c/tree-sitter-eprime.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ 3 | includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ 4 | 5 | Name: tree-sitter-eprime 6 | Description: @PROJECT_DESCRIPTION@ 7 | URL: @PROJECT_HOMEPAGE_URL@ 8 | Version: @PROJECT_VERSION@ 9 | Libs: -L${libdir} -ltree-sitter-eprime 10 | Cflags: -I${includedir} 11 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/c/tree_sitter/tree-sitter-minizinc.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_SITTER_MINIZINC_H_ 2 | #define TREE_SITTER_MINIZINC_H_ 3 | 4 | typedef struct TSLanguage TSLanguage; 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | const TSLanguage *tree_sitter_minizinc(void); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | #endif // TREE_SITTER_MINIZINC_H_ 17 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_exactly_int.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | %-----------------------------------------------------------------------------% 4 | % Requires exactly 'n' variables in 'x' to take the value 'v'. 5 | %-----------------------------------------------------------------------------% 6 | 7 | predicate fzn_exactly_int(int: n, array [int] of var int: x, int: v) = 8 | n == count(x, v); 9 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/c/tree-sitter-datazinc.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ 3 | includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ 4 | 5 | Name: tree-sitter-datazinc 6 | Description: @PROJECT_DESCRIPTION@ 7 | URL: @PROJECT_HOMEPAGE_URL@ 8 | Version: @PROJECT_VERSION@ 9 | Libs: -L${libdir} -ltree-sitter-datazinc 10 | Cflags: -I${includedir} 11 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/c/tree-sitter-minizinc.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ 3 | includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ 4 | 5 | Name: tree-sitter-minizinc 6 | Description: @PROJECT_DESCRIPTION@ 7 | URL: @PROJECT_HOMEPAGE_URL@ 8 | Version: @PROJECT_VERSION@ 9 | Libs: -L${libdir} -ltree-sitter-minizinc 10 | Cflags: -I${includedir} 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_different_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all different. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_different_set(array [int] of var set of int: x) = 6 | forall (i, j in index_set(x) where i < j) (x[i] != x[j]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_range.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_range( 2 | array [int] of var int: x, 3 | var set of int: s, 4 | var set of int: t, 5 | ) = 6 | % All values in 's' must map to a value in 't'. 7 | forall (i in ub(s)) (i in s -> x[i] in t) /\ 8 | % All values in 't' must be mapped from a value in 's'. 9 | forall (i in ub(t)) ( 10 | i in t -> exists (j in ub(s)) (j in s /\ x[j] == i) 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strict_lex2_reif.mzn: -------------------------------------------------------------------------------- 1 | include "lex_chain_less.mzn"; 2 | 3 | predicate fzn_strict_lex2_reif(array [int, int] of var int: x, var bool: b) = 4 | b <-> 5 | lex_chain_less(x) /\ 6 | lex_chain_less( %% transpose 7 | array2d( 8 | index_set_2of2(x), 9 | index_set_1of2(x), 10 | [x[i, j] | j in index_set_2of2(x), i in index_set_1of2(x)], 11 | ), 12 | ); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_tree_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_tree_reif( 2 | int: N, 3 | int: E, 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | var int: r, 7 | array [int] of var bool: ns, 8 | array [int] of var bool: es, 9 | var bool: b, 10 | ) = abort("Reified tree constraint is not supported"); 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_049.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 5 | lt 6 | 7 | 8 | y1 y2 y3 9 | 5 3 10 | ge 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /share/minizinc/std/at_most1.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_at_most1.mzn"; 2 | include "fzn_at_most1_reif.mzn"; 3 | 4 | /** @group globals.counting 5 | Requires that each pair of sets in \a s overlap in at most one element. 6 | */ 7 | predicate at_most1(array [$X] of var set of int: s) = fzn_at_most1(array1d(s)); 8 | 9 | % Synonym for the above. 10 | predicate atmost1(array [$X] of var set of int: s) = at_most1(s); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_bounded_dpath.mzn: -------------------------------------------------------------------------------- 1 | include "path.mzn"; 2 | 3 | predicate fzn_bounded_dpath( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of int: w, 7 | var int: s, 8 | var int: t, 9 | array [int] of var bool: ns, 10 | array [int] of var bool: es, 11 | var int: K, 12 | ) = 13 | dpath(from, to, s, t, ns, es) /\ 14 | K = sum (e in index_set(es)) (es[e] * w[e]); 15 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dwst_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_dwst_reif( 2 | set of int: NODE, 3 | array [int] of int: from, 4 | array [int] of int: to, 5 | array [int] of int: w, 6 | var int: r, 7 | array [int] of var bool: es, 8 | var int: K, 9 | var bool: b, 10 | ) = abort("Reified dwst constraint is not supported"); 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_low_up_closed_set.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_low_up_closed_set( 4 | array [int] of var set of int: x, 5 | array [int] of int: cover, 6 | array [int] of int: lbound, 7 | array [int] of int: ubound, 8 | ) = 9 | global_cardinality(x, cover, lbound, ubound) /\ 10 | forall (v in x) (v subset {d | d in cover}); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_low_up_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_global_cardinality_low_up_reif( 4 | array [int] of var int: x, 5 | array [int] of int: cover, 6 | array [int] of int: lbound, 7 | array [int] of int: ubound, 8 | var bool: b, 9 | ) = 10 | b <-> 11 | forall (i in index_set(cover)) ( 12 | count(x, cover[i]) in lbound[i]..ubound[i] 13 | ); 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_low_up_set.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_global_cardinality_low_up_set( 2 | array [int] of var set of int: x, 3 | array [int] of int: cover, 4 | array [int] of int: lbound, 5 | array [int] of int: ubound, 6 | ) = 7 | forall (i in index_set(cover)) ( 8 | let { 9 | var int: sd = count (v in x) (cover[i] in v); 10 | } in lbound[i] <= sd /\ sd <= ubound[i] 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/set_member.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_set_member.mzn"; 2 | include "fzn_set_member_reif.mzn"; 3 | 4 | %-----------------------------------------------------------------------------% 5 | % Requires that 'y' occurs in the array or set 'x'. 6 | %-----------------------------------------------------------------------------% 7 | 8 | predicate set_member(var set of $$E: x, var $$E: y) = fzn_set_member(x, y); 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_065.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 5 | i 6 | (eq,v) 7 | 8 | 9 | y[] 10 | z 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /docs/src/mzn-syntax.md: -------------------------------------------------------------------------------- 1 | # MiniZinc Syntax Changes 2 | 3 | New syntax includes: 4 | 5 | - Tuples 6 | - Records (which are transformed into tuples) 7 | - `case` expression with complex pattern matching (possibly compiled into `case` with simple matching) 8 | - Namespacing/module system 9 | 10 | Syntax still to be discussed: 11 | 12 | - TypeInst variables syntax 13 | - Function type syntax 14 | - Module syntax 15 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/python/tests/test_binding.py: -------------------------------------------------------------------------------- 1 | from unittest import TestCase 2 | 3 | import tree_sitter 4 | import tree_sitter_eprime 5 | 6 | 7 | class TestLanguage(TestCase): 8 | def test_can_load_grammar(self): 9 | try: 10 | tree_sitter.Language(tree_sitter_eprime.language()) 11 | except Exception: 12 | self.fail("Error loading Eprime grammar") 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_equal_int_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all equal. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_equal_int_reif(array [int] of var int: x, var bool: b) = 6 | b <-> forall (i, j in index_set(x) where i < j) (x[i] = x[j]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_neq.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_neq(array [int] of var int: x, var int: y, var int: c) = 4 | let { var int: z = count(x, y) } in z != c; 5 | % This needs to be written with a let rather than count(x,y) != c 6 | % so that the automatic rewriting of the latter doesn't kick in 7 | 8 | %-----------------------------------------------------------------------------% 9 | -------------------------------------------------------------------------------- /share/minizinc/std/sort_fn.mzn: -------------------------------------------------------------------------------- 1 | include "sort.mzn"; 2 | 3 | /** @group globals.sort 4 | Return a multiset of values that is the same as the 5 | multiset of values in \a x but in sorted order. 6 | */ 7 | function array [int] of var int: sort(array [int] of var int: x) 8 | :: promise_total = 9 | let { 10 | array [1..length(x)] of var lb_array(x)..ub_array(x): y; 11 | constraint sort(x, y); 12 | } in y; 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/knapsack.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | y1 y2 y3 y4 y5 y6 y7 5 | 12 7 21 36 19 22 30 6 | (le,40) 7 | 12 7 21 36 19 22 30 8 | (ge,35) 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /share/minizinc/std/circuit_opt.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_circuit_opt.mzn"; 2 | include "fzn_circuit_opt_reif.mzn"; 3 | 4 | /** @group globals.graph 5 | Constrains the elements of \a x to define a circuit where \a x[\p i] = \p j means 6 | that \p j is the successor of \p i. Absent elements do not take part in the circuit. 7 | */ 8 | predicate circuit(array [$$E] of var opt $$E: x) = 9 | fzn_circuit_opt(erase_enum(x)); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_bin_packing.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_bin_packing( 2 | int: c, 3 | array [int] of var int: bin, 4 | array [int] of int: w, 5 | ) = 6 | let { 7 | int: all_weight = sum(w); 8 | } in forall (b in lb_array(bin)..ub_array(bin)) ( 9 | sum (i in index_set(bin)) (w[i] * (bin[i] != b)) >= all_weight - c 10 | ); 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_strict_opt_decomp.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive_strict_opt_decomp( 2 | array [int] of var opt int: s, 3 | array [int] of var int: d, 4 | ) = 5 | forall (i in index_set(d)) (d[i] >= 0) /\ 6 | forall (i, j in index_set(d) where i < j) ( 7 | absent(s[i]) \/ 8 | absent(s[j]) \/ 9 | deopt(s[i]) + d[i] <= deopt(s[j]) \/ 10 | deopt(s[j]) + d[j] <= deopt(s[i]) 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_knapsack_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_knapsack_reif( 2 | array [int] of int: w, 3 | array [int] of int: p, 4 | array [int] of var int: x, 5 | var int: W, 6 | var int: P, 7 | var bool: b, 8 | ) = 9 | b <-> 10 | forall (i in index_set(x)) (x[i] >= 0) /\ 11 | W >= 0 /\ 12 | P >= 0 /\ 13 | P = sum (i in index_set(p)) (x[i] * p[i]) /\ 14 | W = sum (i in index_set(w)) (x[i] * w[i]); 15 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_chain_int_opt.mzn: -------------------------------------------------------------------------------- 1 | include "value_precede_chain.mzn"; 2 | 3 | predicate fzn_value_precede_chain_int_opt( 4 | array [int] of int: T, 5 | array [int] of var opt int: X, 6 | ) = 7 | let { 8 | int: def = if had_zero(X) then max(T) + 1 else 0 endif; 9 | array [int] of var int: x = 10 | array1d(index_set(X), [xi default def | xi in X]); 11 | } in value_precede_chain(T, x); 12 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_005.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1..10 4 | 1..100 5 | 6 | 7 | 8 | eq(y,mul(x,x)) 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_037.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 5 | (0,1,0)(1,0,0)(1,1,0)(1,1,1) 6 | 7 | 8 | y1 y2 y3 y4 9 | (1,2,3,4)(3,1,3,4) 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/python/tests/test_binding.py: -------------------------------------------------------------------------------- 1 | from unittest import TestCase 2 | 3 | import tree_sitter 4 | import tree_sitter_datazinc 5 | 6 | 7 | class TestLanguage(TestCase): 8 | def test_can_load_grammar(self): 9 | try: 10 | tree_sitter.Language(tree_sitter_datazinc.language()) 11 | except Exception: 12 | self.fail("Error loading Datazinc grammar") 13 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/python/tests/test_binding.py: -------------------------------------------------------------------------------- 1 | from unittest import TestCase 2 | 3 | import tree_sitter 4 | import tree_sitter_minizinc 5 | 6 | 7 | class TestLanguage(TestCase): 8 | def test_can_load_grammar(self): 9 | try: 10 | tree_sitter.Language(tree_sitter_minizinc.language()) 11 | except Exception: 12 | self.fail("Error loading Minizinc grammar") 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_different_int_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all different. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_different_int_reif(array [int] of var int: x, var bool: b) = 6 | b <-> forall (i, j in index_set(x) where i < j) (x[i] != x[j]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_bin_packing_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_bin_packing_reif( 2 | int: c, 3 | array [int] of var int: bin, 4 | array [int] of int: w, 5 | var bool: b, 6 | ) = 7 | b <-> 8 | forall (assigned_bin in lb_array(bin)..ub_array(bin)) ( 9 | c >= sum (i in index_set(bin)) (w[i] * (bin[i] == assigned_bin)) 10 | ); 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_int.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_int(array [int] of var int: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_low_up_closed_opt.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_low_up_closed_opt( 4 | array [int] of var opt int: x, 5 | array [int] of int: cover, 6 | array [int] of int: lbound, 7 | array [int] of int: ubound, 8 | ) = 9 | forall (xi in x) (absent(xi) \/ deopt(xi) in {d | d in cover}) /\ 10 | global_cardinality(x, cover, lbound, ubound); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_int.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_int(array [int] of var int: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_int_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_int_reif( 6 | array [int] of var int: x, 7 | var int: y, 8 | var bool: b, 9 | ) = b <-> exists (i in index_set(x)) (x[i] == y); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_decreasing_bool.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict decreasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_decreasing_bool(array [int] of var bool: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] > x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_decreasing_int.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict decreasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_decreasing_int(array [int] of var int: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] > x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_increasing_bool.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict increasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_increasing_bool(array [int] of var bool: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] < x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_increasing_int.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict increasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_increasing_int(array [int] of var int: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] < x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/sliding_sum.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_sliding_sum.mzn"; 2 | include "fzn_sliding_sum_reif.mzn"; 3 | 4 | /** @group globals.math 5 | Requires that in each subsequence \a vs[\p i], ..., \a vs[\p i + \a seq - 1] the sum of the 6 | values belongs to the interval [\a low, \a up]. 7 | */ 8 | predicate sliding_sum(int: low, int: up, int: seq, array [int] of var int: vs) = 9 | fzn_sliding_sum(low, up, seq, vs); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_equal_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all equal. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_equal_set_reif( 6 | array [int] of var set of int: x, 7 | var bool: b, 8 | ) = b <-> forall (i, j in index_set(x) where i < j) (x[i] = x[j]); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_at_most_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires at most 'n' variables in 'x' to take the value 'v'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_at_most_set( 6 | int: n, 7 | array [int] of var set of int: x, 8 | set of int: v, 9 | ) = sum (i in index_set(x)) (x[i] == v) <= n; 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_circuit_opt_reif.mzn: -------------------------------------------------------------------------------- 1 | include "subcircuit.mzn"; 2 | 3 | predicate fzn_circuit_opt_reif(array [int] of var opt int: x, var bool: b) = 4 | b <-> 5 | subcircuit( 6 | array1d( 7 | index_set(x), 8 | [ 9 | if occurs(x[i]) then deopt(x[i]) else i endif | 10 | i in index_set(x), 11 | ], 12 | ), 13 | ) /\ 14 | forall (i in index_set(x)) (occurs(x[i]) -> deopt(x[i]) != i); 15 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_bool.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_bool(array [int] of var bool: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_float.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_float(array [int] of var float: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_set(array [int] of var set of int: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_opt_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive_opt_reif( 2 | array [int] of var opt int: s, 3 | array [int] of var int: d, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i, j in index_set(d) where i < j) ( 8 | absent(s[i]) \/ 9 | absent(s[j]) \/ 10 | d[i] = 0 \/ 11 | d[j] = 0 \/ 12 | deopt(s[i]) + d[i] <= deopt(s[j]) \/ 13 | deopt(s[j]) + d[j] <= deopt(s[i]) 14 | ); 15 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_exactly_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires exactly 'n' variables in 'x' to take the value 'v'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_exactly_set( 6 | int: n, 7 | array [int] of var set of int: x, 8 | set of int: v, 9 | ) = n == sum (i in index_set(x)) (x[i] == v); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_bool.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_bool(array [int] of var bool: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_float.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_float(array [int] of var float: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_set(array [int] of var set of int: x) = 6 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 7 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_bool_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_bool_reif( 6 | array [int] of var bool: x, 7 | var bool: y, 8 | var bool: b, 9 | ) = b <-> exists (i in index_set(x)) (x[i] == y); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_subgraph_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_subgraph_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | array [int] of var bool: ns, 5 | array [int] of var bool: es, 6 | var bool: b, 7 | ) = 8 | b <-> 9 | forall (e in index_set(from)) ( 10 | (es[e] -> ns[from[e]]) /\ (es[e] -> ns[to[e]]) 11 | ); 12 | 13 | %-----------------------------------------------------------------------------% 14 | -------------------------------------------------------------------------------- /share/minizinc/std/redefinitions-2.2.1.mzn: -------------------------------------------------------------------------------- 1 | % This file contains redefinitions of standard builtins for version 2.2.1 2 | % that can be overridden by solvers. 3 | 4 | predicate int_pow_fixed(var int: x, int: y, var int: z) = 5 | if y = 0 then 6 | z = 1 7 | elseif y = 1 then 8 | z = x 9 | else 10 | if y >= 0 then 11 | z = product([x | i in 1..y]) 12 | else 13 | z = 1 div pow(x, -y) 14 | endif 15 | endif; 16 | -------------------------------------------------------------------------------- /share/minizinc/std/circuit.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_circuit.mzn"; 2 | include "fzn_circuit_reif.mzn"; 3 | 4 | /** @group globals.graph 5 | Constrains the elements of \a x to define a circuit where \a x[\p i] = \p j means 6 | that \p j is the successor of \p i. 7 | */ 8 | predicate circuit(array [$$E] of var $$E: x) = fzn_circuit(erase_enum(x)); 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_at_least_set.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires at least 'n' variables in 'x' to take the value 'v'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_at_least_set( 6 | int: n, 7 | array [int] of var set of int: x, 8 | set of int: v, 9 | ) = sum (i in index_set(x)) (x[i] == v) >= n; 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dsteiner_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_dsteiner_reif( 2 | array [int] of int: from, 3 | array [int] of int: to, 4 | array [int] of int: w, 5 | var int: r, 6 | array [int] of var bool: ns, 7 | array [int] of var bool: es, 8 | var int: K, 9 | var bool: b, 10 | ) = abort("Reified steiner constraint is not supported"); 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_inverse_set_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_inverse_set_reif( 2 | array [int] of var set of int: f, 3 | array [int] of var set of int: invf, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i in index_set(f)) (f[i] subset index_set(invf)) /\ 8 | forall (j in index_set(invf)) (invf[j] subset index_set(f)) /\ 9 | forall (i in index_set(f), j in index_set(invf)) ( 10 | j in f[i] <-> i in invf[j] 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_float_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array or set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_float_reif( 6 | array [int] of var float: x, 7 | var float: y, 8 | var bool: b, 9 | ) = b <-> exists (i in index_set(x)) (x[i] == y); 10 | -------------------------------------------------------------------------------- /editors/code/.vscodeignore: -------------------------------------------------------------------------------- 1 | vscode/** 2 | **/*.ts 3 | **/*.map 4 | .gitignore 5 | **/tsconfig.json 6 | **/tsconfig.base.json 7 | node_modules/** 8 | !node_modules/vscode-jsonrpc/** 9 | !node_modules/vscode-language** 10 | !node_modules/vscode-languageserver-protocol/** 11 | !node_modules/vscode-languageserver-types/** 12 | !node_modules/{minimatch,brace-expansion,concat-map,balanced-match}/** 13 | !node_modules/{semver,lru-cache,yallist}/** -------------------------------------------------------------------------------- /share/minizinc/std/fzn_member_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that 'y' occurs in the array of set 'x'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_member_set_reif( 6 | array [int] of var set of int: x, 7 | var set of int: y, 8 | var bool: b, 9 | ) = b <-> exists (i in index_set(x)) (x[i] == y); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_steiner_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_steiner_reif( 2 | int: N, 3 | int: E, 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of int: w, 7 | array [int] of var bool: ns, 8 | array [int] of var bool: es, 9 | var int: K, 10 | var bool: b, 11 | ) = abort("Reified steiner constraint is not supported"); 12 | 13 | %-----------------------------------------------------------------------------% 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_all_different_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Constrains the array of objects 'x' to be all different. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_all_different_set_reif( 6 | array [int] of var set of int: x, 7 | var bool: b, 8 | ) = b <-> forall (i, j in index_set(x) where i < j) (x[i] != x[j]); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_opt.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_opt( 4 | array [int] of var opt int: x, 5 | array [int] of int: cover, 6 | array [int] of var int: counts, 7 | ) = 8 | let { 9 | % Set <> to something outside the cover 10 | int: def = if 0 in cover then min(cover) - 1 else 0 endif; 11 | } in global_cardinality([x_i default def | x_i in x], cover, counts); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_int_set_channel.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_int_set_channel( 2 | array [int] of var int: x, 3 | array [int] of var set of int: y, 4 | ) = 5 | forall (i in index_set(x)) (x[i] in index_set(y)) /\ 6 | forall (j in index_set(y)) (y[j] subset index_set(x)) /\ 7 | forall (i in index_set(x), j in index_set(y)) (x[i] = j <-> i in y[j]); 8 | 9 | %-----------------------------------------------------------------------------% 10 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/.gitattributes: -------------------------------------------------------------------------------- 1 | * text eol=lf 2 | 3 | src/*.json linguist-generated 4 | src/parser.c linguist-generated 5 | src/tree_sitter/* linguist-generated 6 | 7 | bindings/** linguist-generated 8 | binding.gyp linguist-generated 9 | setup.py linguist-generated 10 | Makefile linguist-generated 11 | Package.swift linguist-generated 12 | 13 | # Zig bindings 14 | build.zig linguist-generated 15 | build.zig.zon linguist-generated 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_bounded_path_reif.mzn: -------------------------------------------------------------------------------- 1 | include "path.mzn"; 2 | 3 | predicate fzn_bounded_path_reif( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of int: w, 7 | var int: s, 8 | var int: t, 9 | array [int] of var bool: ns, 10 | array [int] of var bool: es, 11 | var int: K, 12 | var bool: b, 13 | ) = 14 | b <-> 15 | path(from, to, s, t, ns, es) /\ 16 | K = sum (e in index_set(es)) (es[e] * w[e]); 17 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_bool_opt.mzn: -------------------------------------------------------------------------------- 1 | include "increasing.mzn"; 2 | 3 | predicate fzn_increasing_bool(array [int] of var opt bool: x) = 4 | let { 5 | array [index_set(x)] of var bool: xx; 6 | constraint 7 | xx[min(index_set(x))] = x[min(index_set(x))] default lb_array(x); 8 | constraint 9 | forall (i in min(index_set(x)) + 1..max(index_set(x))) ( 10 | xx[i] = x[i] default xx[i - 1] 11 | ); 12 | } in increasing(xx); 13 | -------------------------------------------------------------------------------- /docs/src/compilation/bytecode-gen.md: -------------------------------------------------------------------------------- 1 | # Bytecode generation 2 | 3 | ## Output generation 4 | 5 | Some kind of code which maps from FlatZinc output variables to user model 6 | output should be generated similarly to how we generate `.ozn` output models 7 | currently. 8 | 9 | This functionality could be extended to allow for mapping of other solver 10 | information such as statistics, duals, etc to report these in the context of 11 | the user model. 12 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/go/binding.go: -------------------------------------------------------------------------------- 1 | package tree_sitter_eprime 2 | 3 | // #cgo CFLAGS: -std=c11 -fPIC 4 | // #include "../../src/parser.c" 5 | // #if __has_include("../../src/scanner.c") 6 | // #include "../../src/scanner.c" 7 | // #endif 8 | import "C" 9 | 10 | import "unsafe" 11 | 12 | // Get the tree-sitter Language for this grammar. 13 | func Language() unsafe.Pointer { 14 | return unsafe.Pointer(C.tree_sitter_eprime()) 15 | } 16 | -------------------------------------------------------------------------------- /share/minizinc/std/among_fn.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_among.mzn"; 2 | 3 | /** @group globals.counting 4 | Returns the number of variables in \a x that take one of the values in \a v. 5 | */ 6 | function var int: among(array [$X] of var $$E: x, set of $$E: v) 7 | :: promise_total = 8 | let { 9 | var 0..length(x): n :: is_defined_var; 10 | constraint 11 | fzn_among(n, erase_enum(array1d(x)), erase_enum(v)) 12 | :: defines_var(n); 13 | } in n; 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_bounded_dpath_reif.mzn: -------------------------------------------------------------------------------- 1 | include "path.mzn"; 2 | 3 | predicate fzn_bounded_dpath_reif( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of int: w, 7 | var int: s, 8 | var int: t, 9 | array [int] of var bool: ns, 10 | array [int] of var bool: es, 11 | var int: K, 12 | var bool: b, 13 | ) = 14 | b <-> 15 | dpath(from, to, s, t, ns, es) /\ 16 | K = sum (e in index_set(es)) (es[e] * w[e]); 17 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_disjunctive_strict_opt_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_disjunctive_strict_opt_reif( 2 | array [int] of var opt int: s, 3 | array [int] of var int: d, 4 | var bool: b, 5 | ) = 6 | b <-> 7 | forall (i in index_set(d)) (d[i] >= 0) /\ 8 | forall (i, j in index_set(d) where i < j) ( 9 | absent(s[i]) \/ 10 | absent(s[j]) \/ 11 | deopt(s[i]) + d[i] <= deopt(s[j]) \/ 12 | deopt(s[j]) + d[j] <= deopt(s[i]) 13 | ); 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_dsteiner.mzn: -------------------------------------------------------------------------------- 1 | include "tree.mzn"; 2 | 3 | predicate fzn_dsteiner( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of int: w, 7 | var int: r, 8 | array [int] of var bool: ns, 9 | array [int] of var bool: es, 10 | var int: K, 11 | ) = dtree(from, to, r, ns, es) /\ K = sum (e in index_set(es)) (es[e] * w[e]); 12 | 13 | %-----------------------------------------------------------------------------% 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_bool.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_bool( 2 | array [int] of var bool: c, 3 | array [int] of bool: x, 4 | var bool: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_int.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_int( 2 | array [int] of var bool: c, 3 | array [int] of int: x, 4 | var int: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_path_reif.mzn: -------------------------------------------------------------------------------- 1 | include "tree.mzn"; 2 | include "subgraph.mzn"; 3 | 4 | predicate fzn_path_reif( 5 | array [int] of int: from, 6 | array [int] of int: to, 7 | var int: s, 8 | var int: t, 9 | array [int] of var bool: ns, 10 | array [int] of var bool: es, 11 | var bool: b, 12 | ) = abort("Reified path constraint is not supported"); 13 | 14 | %-----------------------------------------------------------------------------% 15 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_range_reif.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_range_reif( 2 | array [int] of var int: x, 3 | var set of int: s, 4 | var set of int: t, 5 | var bool: b, 6 | ) = 7 | b <-> 8 | % All values in 's' must map to a value in 't'. 9 | forall (i in ub(s)) (i in s -> x[i] in t) /\ 10 | % All values in 't' must be mapped from a value in 's'. 11 | forall (i in ub(t)) ( 12 | i in t -> exists (j in ub(s)) (j in s /\ x[j] == i) 13 | ); 14 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/go/binding.go: -------------------------------------------------------------------------------- 1 | package tree_sitter_datazinc 2 | 3 | // #cgo CFLAGS: -std=c11 -fPIC 4 | // #include "../../src/parser.c" 5 | // #if __has_include("../../src/scanner.c") 6 | // #include "../../src/scanner.c" 7 | // #endif 8 | import "C" 9 | 10 | import "unsafe" 11 | 12 | // Get the tree-sitter Language for this grammar. 13 | func Language() unsafe.Pointer { 14 | return unsafe.Pointer(C.tree_sitter_datazinc()) 15 | } 16 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/go/binding.go: -------------------------------------------------------------------------------- 1 | package tree_sitter_minizinc 2 | 3 | // #cgo CFLAGS: -std=c11 -fPIC 4 | // #include "../../src/parser.c" 5 | // #if __has_include("../../src/scanner.c") 6 | // #include "../../src/scanner.c" 7 | // #endif 8 | import "C" 9 | 10 | import "unsafe" 11 | 12 | // Get the tree-sitter Language for this grammar. 13 | func Language() unsafe.Pointer { 14 | return unsafe.Pointer(C.tree_sitter_minizinc()) 15 | } 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_int_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_int_reif(array [int] of var int: x, var bool: b) = 6 | b <-> 7 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_exactly_int_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | %-----------------------------------------------------------------------------% 4 | % Requires exactly 'n' variables in 'x' to take the value 'v'. 5 | %-----------------------------------------------------------------------------% 6 | 7 | predicate fzn_exactly_int_reif( 8 | int: n, 9 | array [int] of var int: x, 10 | int: v, 11 | var bool: b, 12 | ) = b <-> n == count(x, v); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_float.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_float( 2 | array [int] of var bool: c, 3 | array [int] of float: x, 4 | var float: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_int_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_int_reif(array [int] of var int: x, var bool: b) = 6 | b <-> 7 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 8 | -------------------------------------------------------------------------------- /docs/src/compilation/thir/records.md: -------------------------------------------------------------------------------- 1 | # Erasure of records 2 | 3 | Erasing records into tuples involves transforming record literals into tuples, 4 | and record access into tuple access, ensuring that the order of the fields 5 | remains consistent. 6 | 7 | ```mzn 8 | record(int: foo, float: bar): x = (bar: 1.5, foo: 2); 9 | int: y = x.foo; 10 | ``` 11 | 12 | Transforms into 13 | 14 | ```mzn 15 | tuple(float, int): x = (1.5, 2); 16 | int: y = x.2; 17 | ``` 18 | -------------------------------------------------------------------------------- /share/minizinc/std/exactly_int.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_exactly_int.mzn"; 2 | include "fzn_exactly_int_reif.mzn"; 3 | 4 | %-----------------------------------------------------------------------------% 5 | % Requires exactly 'n' variables in 'x' to take the value 'v'. 6 | %-----------------------------------------------------------------------------% 7 | 8 | predicate exactly_int(int: n, array [$X] of var $$E: x, $$E: v) = 9 | fzn_exactly_int(n, array1d(x), v); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_at_most_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires at most 'n' variables in 'x' to take the value 'v'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_at_most_set_reif( 6 | int: n, 7 | array [int] of var set of int: x, 8 | set of int: v, 9 | var bool: b, 10 | ) = b <-> sum (i in index_set(x)) (x[i] == v) <= n; 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_bool_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_bool_reif(array [int] of var bool: x, var bool: b) = 6 | b <-> 7 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_float_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_float_reif(array [int] of var float: x, var bool: b) = 6 | b <-> 7 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_diffn.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_diffn( 2 | array [int] of var int: x, 3 | array [int] of var int: y, 4 | array [int] of var int: dx, 5 | array [int] of var int: dy, 6 | ) = 7 | forall (i, j in index_set(x) where i < j) ( 8 | x[i] + dx[i] <= x[j] \/ 9 | y[i] + dy[i] <= y[j] \/ 10 | x[j] + dx[j] <= x[i] \/ 11 | y[j] + dy[j] <= y[i] 12 | ); 13 | 14 | %-----------------------------------------------------------------------------% 15 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_exactly_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires exactly 'n' variables in 'x' to take the value 'v'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_exactly_set_reif( 6 | int: n, 7 | array [int] of var set of int: x, 8 | set of int: v, 9 | var bool: b, 10 | ) = b <-> n == sum (i in index_set(x)) (x[i] == v); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_set.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_set( 2 | array [int] of var bool: c, 3 | array [int] of set of int: x, 4 | var set of int: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_var_int.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_var_int( 2 | array [int] of var bool: c, 3 | array [int] of var int: x, 4 | var int: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_bool_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_bool_reif(array [int] of var bool: x, var bool: b) = 6 | b <-> 7 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_float_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_float_reif(array [int] of var float: x, var bool: b) = 6 | b <-> 7 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 8 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_decreasing_bool_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict decreasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_decreasing_bool_reif( 6 | array [int] of var bool: x, 7 | var bool: b, 8 | ) = b <-> forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] > x[i]); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_decreasing_int_opt.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_strictly_increasing_int_opt.mzn"; 2 | 3 | %-----------------------------------------------------------------------------% 4 | % Requires that the array 'x' is in strict decreasing order 5 | %-----------------------------------------------------------------------------% 6 | 7 | predicate fzn_strictly_decreasing_int_opt(array [int] of var opt int: x) = 8 | fzn_strictly_increasing_int_opt(reverse(x)); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_decreasing_int_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict decreasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_decreasing_int_reif( 6 | array [int] of var int: x, 7 | var bool: b, 8 | ) = b <-> forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] > x[i]); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_increasing_bool_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict increasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_increasing_bool_reif( 6 | array [int] of var bool: x, 7 | var bool: b, 8 | ) = b <-> forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] < x[i]); 9 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_strictly_increasing_int_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in strict increasing order 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_strictly_increasing_int_reif( 6 | array [int] of var int: x, 7 | var bool: b, 8 | ) = b <-> forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] < x[i]); 9 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_136.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | b1 b2 b3 b4 4 | 5 | (a,0,a)(a,1,b)(b,0,c)(b,1,d)(c,0,d) 6 | 7 | a 8 | d 9 | 10 | 11 | 12 | (10,0)(0,5)(5,2)(5,0) 13 | (le,z) 14 | 15 | 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_at_least_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires at least 'n' variables in 'x' to take the value 'v'. 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_at_least_set_reif( 6 | int: n, 7 | array [int] of var set of int: x, 8 | set of int: v, 9 | var bool: b, 10 | ) = b <-> sum (i in index_set(x)) (x[i] == v) >= n; 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_opt_int.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_opt_int( 2 | array [int] of var bool: c, 3 | array [int] of opt int: x, 4 | var opt int: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_var_bool.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_var_bool( 2 | array [int] of var bool: c, 3 | array [int] of var bool: x, 4 | var bool: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/redefinitions-2.1.mzn: -------------------------------------------------------------------------------- 1 | % This file contains redefinitions of standard builtins for version 2.1 2 | % that can be overridden by solvers. 3 | 4 | predicate float_in(var float: x, float: a, float: b) = x >= a /\ x <= b; 5 | 6 | predicate float_dom(var float: x, array [int] of float: as) = 7 | let { 8 | array [int] of var bool: b = [ 9 | float_in(x, as[2 * i - 1], as[2 * i]) | 10 | i in 1..length(as) div 2, 11 | ]; 12 | } in exists(b); 13 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_023.debug.txt: -------------------------------------------------------------------------------- 1 | Instantiation { 2 | info: MetaInfo { 3 | identifier: None, 4 | note: None, 5 | }, 6 | ty: Some( 7 | Optimum, 8 | ), 9 | cost: Some( 10 | 1700, 11 | ), 12 | list: [ 13 | Ident( 14 | "b", 15 | ), 16 | Ident( 17 | "c", 18 | ), 19 | ], 20 | values: [ 21 | 2, 22 | 2, 23 | ], 24 | } 25 | -------------------------------------------------------------------------------- /share/minizinc/std/count_fn.mzn: -------------------------------------------------------------------------------- 1 | include "count.mzn"; 2 | 3 | /** @group globals.counting 4 | Returns the number of occurrences of \a y in \a x. 5 | */ 6 | function var int: count(array [$X] of var $$E: x, var $$E: y) :: promise_total = 7 | let { 8 | var 0..length(x): c :: is_defined_var; 9 | constraint count(array1d(x), y, c) :: defines_var(c); 10 | } in c; 11 | 12 | function int: count(array [$X] of $$E: x, $$E: y) = 13 | count (i in array1d(x)) (i = y); 14 | -------------------------------------------------------------------------------- /share/minizinc/std/exactly_set.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_exactly_set.mzn"; 2 | include "fzn_exactly_set_reif.mzn"; 3 | 4 | %-----------------------------------------------------------------------------% 5 | % Requires exactly 'n' variables in 'x' to take the value 'v'. 6 | %-----------------------------------------------------------------------------% 7 | 8 | predicate exactly_set(int: n, array [$X] of var set of $$E: x, set of $$E: v) = 9 | fzn_exactly_set(n, array1d(x), v); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_gt_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_gt_reif( 4 | array [int] of var int: x, 5 | var int: y, 6 | var int: c, 7 | var bool: b, 8 | ) = let { var int: z = count(x, y) } in b <-> z < c; 9 | % This needs to be written with a let rather than count(x,y) < c 10 | % so that the automatic rewriting of the latter doesn't kick in 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_leq.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_leq(array [int] of var int: x, var int: y, var int: c) = 4 | let { 5 | var int: z :: promise_ctx_monotone = count (xi in x) (xi == y); 6 | } in z >= c; 7 | % This needs to be written with a let rather than count(x,y) >= c 8 | % so that the automatic rewriting of the latter doesn't kick in 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_lt.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_lt(array [int] of var int: x, var int: y, var int: c) = 4 | let { 5 | var int: z :: promise_ctx_monotone = count (xi in x) (xi == y); 6 | } in z > c; 7 | % This needs to be written with a let rather than count(x,y) >= c 8 | % so that the automatic rewriting of the latter doesn't kick in 9 | 10 | %-----------------------------------------------------------------------------% 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_lt_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_lt_reif( 4 | array [int] of var int: x, 5 | var int: y, 6 | var int: c, 7 | var bool: b, 8 | ) = let { var int: z = count(x, y) } in b <-> z > c; 9 | % This needs to be written with a let rather than count(x,y) > c 10 | % so that the automatic rewriting of the latter doesn't kick in 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_opt_bool.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_opt_bool( 2 | array [int] of var bool: c, 3 | array [int] of opt bool: x, 4 | var opt bool: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_opt_float.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_opt_float( 2 | array [int] of var bool: c, 3 | array [int] of opt float: x, 4 | var opt float: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_var_float.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_var_float( 2 | array [int] of var bool: c, 3 | array [int] of var float: x, 4 | var float: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_seq_precede_chain_int.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_seq_precede_chain_int(array [int] of var int: X) = 2 | let { 3 | int: l = lb_array(X); % least possible value 4 | int: u = ub_array(X); % greatest possible value 5 | int: f = min(index_set(X)); 6 | array [index_set(X)] of var l..u: H; 7 | } in H[f] <= 1 /\ 8 | H[f] = max(X[f], 0) /\ 9 | forall (i in index_set(X) diff {f}) ( 10 | H[i] <= H[i - 1] + 1 /\ H[i] = max(X[i], H[i - 1]) 11 | ); 12 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_sort.mzn: -------------------------------------------------------------------------------- 1 | include "alldifferent.mzn"; 2 | include "increasing.mzn"; 3 | 4 | predicate fzn_sort(array [int] of var int: x, array [int] of var int: y) = 5 | let { 6 | int: lx = min(index_set(x)); 7 | int: ux = max(index_set(x)); 8 | int: ly = min(index_set(y)); 9 | int: uy = max(index_set(y)); 10 | array [lx..ux] of var ly..uy: p; 11 | } in forall (i in index_set(x)) (y[p[i]] == x[i]) /\ 12 | alldifferent(p) /\ 13 | increasing(y); 14 | -------------------------------------------------------------------------------- /parsers/tree-sitter-eprime/bindings/go/binding_test.go: -------------------------------------------------------------------------------- 1 | package tree_sitter_eprime_test 2 | 3 | import ( 4 | "testing" 5 | 6 | tree_sitter "github.com/tree-sitter/go-tree-sitter" 7 | tree_sitter_eprime "git+github.com/shackle-rs/shackle.git/bindings/go" 8 | ) 9 | 10 | func TestCanLoadGrammar(t *testing.T) { 11 | language := tree_sitter.NewLanguage(tree_sitter_eprime.Language()) 12 | if language == nil { 13 | t.Errorf("Error loading Eprime grammar") 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_geq_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_geq_reif( 4 | array [int] of var int: x, 5 | var int: y, 6 | var int: c, 7 | var bool: b, 8 | ) = let { var int: z = count(x, y) } in b <-> z <= c; 9 | % This needs to be written with a let rather than count(x,y) <= c 10 | % so that the automatic rewriting of the latter doesn't kick in 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_leq_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_leq_reif( 4 | array [int] of var int: x, 5 | var int: y, 6 | var int: c, 7 | var bool: b, 8 | ) = let { var int: z = count(x, y) } in b <-> z >= c; 9 | % This needs to be written with a let rather than count(x,y) >= c 10 | % so that the automatic rewriting of the latter doesn't kick in 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_count_neq_reif.mzn: -------------------------------------------------------------------------------- 1 | include "count_fn.mzn"; 2 | 3 | predicate fzn_count_neq_reif( 4 | array [int] of var int: x, 5 | var int: y, 6 | var int: c, 7 | var bool: b, 8 | ) = let { var int: z = count(x, y) } in b <-> z != c; 9 | % This needs to be written with a let rather than count(x,y) != c 10 | % so that the automatic rewriting of the latter doesn't kick in 11 | 12 | %-----------------------------------------------------------------------------% 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_diffn_nonstrict.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_diffn_nonstrict( 2 | array [int] of var int: x, 3 | array [int] of var int: y, 4 | array [int] of var int: dx, 5 | array [int] of var int: dy, 6 | ) = 7 | forall (i, j in index_set(x) where i < j) ( 8 | dx[i] = 0 \/ 9 | dx[j] = 0 \/ 10 | dy[i] = 0 \/ 11 | dy[j] = 0 \/ 12 | x[i] + dx[i] <= x[j] \/ 13 | y[i] + dy[i] <= y[j] \/ 14 | x[j] + dx[j] <= x[i] \/ 15 | y[j] + dy[j] <= y[i] 16 | ); 17 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_var_opt_int.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_var_opt_int( 2 | array [int] of var bool: c, 3 | array [int] of var opt int: x, 4 | var opt int: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_var_set.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_var_set( 2 | array [int] of var bool: c, 3 | array [int] of var set of int: x, 4 | var set of int: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/sort.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_sort.mzn"; 2 | include "fzn_sort_reif.mzn"; 3 | 4 | /** @group globals.sort 5 | Requires that the multiset of values in \a x are the same as the 6 | multiset of values in \a y but \a y is in sorted order. 7 | */ 8 | predicate sort(array [int] of var int: x, array [int] of var int: y) = 9 | assert( 10 | card(index_set(x)) == card(index_set(y)), 11 | "sort: x and y must be same sized arrays", 12 | fzn_sort(x, y), 13 | ); 14 | -------------------------------------------------------------------------------- /docs/book.toml: -------------------------------------------------------------------------------- 1 | [book] 2 | authors = ["Jip J. Dekker"] 3 | language = "en" 4 | multilingual = false 5 | src = "src" 6 | title = "The Shackle Almanac" 7 | 8 | [output.html] 9 | additional-js = ["theme/mzn-highlight.js"] 10 | # TODO: We use newer version (3.1+) of MathJax for the proofs. Remove custom "head.hbs" code when possible 11 | mathjax-support = false 12 | 13 | [output.html.fold] 14 | enable = true 15 | 16 | [preprocessor.mermaid] 17 | command = "python utils/mermaid.py" 18 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_bin_packing_capa.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_bin_packing_capa( 2 | array [int] of int: c, 3 | array [int] of var int: bin, 4 | array [int] of int: w, 5 | ) = 6 | forall (i in index_set(bin)) ( 7 | min(index_set(c)) <= bin[i] /\ bin[i] <= max(index_set(c)) 8 | ) /\ 9 | forall (b in index_set(c)) ( 10 | c[b] >= sum (i in index_set(bin)) (w[i] * (bin[i] = b)) 11 | ); 12 | 13 | %-----------------------------------------------------------------------------% 14 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_var_opt_bool.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_var_opt_bool( 2 | array [int] of var bool: c, 3 | array [int] of var opt bool: x, 4 | var opt bool: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_value_precede_int.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_value_precede_int(int: s, int: t, array [int] of var int: x) = 2 | let { 3 | int: imin = min(index_set(x)); 4 | int: imax = max(index_set(x)); 5 | array [imin..imax + 1] of var bool: b; 6 | } in forall (i in imin..imax) ( 7 | let { 8 | var bool: xis = x[i] == s; 9 | } in (xis -> b[i + 1] == true) /\ 10 | (not xis -> b[i] == b[i + 1]) /\ 11 | (not b[i] -> x[i] != t) 12 | ) /\ 13 | b[imin] == false; 14 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_027.debug.txt: -------------------------------------------------------------------------------- 1 | Instantiation { 2 | info: MetaInfo { 3 | identifier: None, 4 | note: None, 5 | }, 6 | ty: Some( 7 | Solution, 8 | ), 9 | cost: None, 10 | list: [ 11 | ArrayAccess( 12 | "x", 13 | [ 14 | Full, 15 | ], 16 | ), 17 | ], 18 | values: [ 19 | 1, 20 | 1, 21 | 2, 22 | 1, 23 | ], 24 | } 25 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_127.xml: -------------------------------------------------------------------------------- 1 | 2 | x1 x2 x3 x4 3 | eq(add(%0,%1),%2) 4 | 5 | 6 | y1 y2 y3 y4 7 | 8 | %0 %1 9 | (a,a)(a,c)(b,b)(c,a)(c,b) 10 | 11 | 12 | 13 | w1 z1 w2 z2 w3 z3 14 | ne(%0,%1) 15 | 16 | -------------------------------------------------------------------------------- /parsers/tree-sitter-datazinc/bindings/go/binding_test.go: -------------------------------------------------------------------------------- 1 | package tree_sitter_datazinc_test 2 | 3 | import ( 4 | "testing" 5 | 6 | tree_sitter "github.com/tree-sitter/go-tree-sitter" 7 | tree_sitter_datazinc "git+github.com/shackle-rs/shackle.git/bindings/go" 8 | ) 9 | 10 | func TestCanLoadGrammar(t *testing.T) { 11 | language := tree_sitter.NewLanguage(tree_sitter_datazinc.Language()) 12 | if language == nil { 13 | t.Errorf("Error loading Datazinc grammar") 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /parsers/tree-sitter-minizinc/bindings/go/binding_test.go: -------------------------------------------------------------------------------- 1 | package tree_sitter_minizinc_test 2 | 3 | import ( 4 | "testing" 5 | 6 | tree_sitter "github.com/tree-sitter/go-tree-sitter" 7 | tree_sitter_minizinc "git+github.com/shackle-rs/shackle.git/bindings/go" 8 | ) 9 | 10 | func TestCanLoadGrammar(t *testing.T) { 11 | language := tree_sitter.NewLanguage(tree_sitter_minizinc.Language()) 12 | if language == nil { 13 | t.Errorf("Error loading Minizinc grammar") 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_low_up_closed.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_global_cardinality_low_up_closed( 2 | array [int] of var int: x, 3 | array [int] of int: cover, 4 | array [int] of int: lbound, 5 | array [int] of int: ubound, 6 | ) = 7 | forall (i in index_set(x)) (x[i] in {d | d in array2set(cover)}) /\ 8 | global_cardinality(x, cover, lbound, ubound) /\ 9 | % Implied condition 10 | length(x) in sum(lbound)..sum(ubound); 11 | 12 | include "global_cardinality.mzn"; 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_if_then_else_var_opt_float.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_if_then_else_var_opt_float( 2 | array [int] of var bool: c, 3 | array [int] of var opt float: x, 4 | var opt float: y, 5 | ) = 6 | let { 7 | array [index_set(c)] of var bool: d; 8 | } in forall (i in index_set(c)) ( 9 | if i > min(index_set(c)) then 10 | d[i] = (not c[i - 1] /\ d[i - 1]) 11 | else 12 | d[i] = true 13 | endif 14 | ) /\ 15 | forall (i in index_set(c)) (c[i] /\ d[i] -> y = x[i]); 16 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_decreasing_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in decreasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_decreasing_set_reif( 6 | array [int] of var set of int: x, 7 | var bool: b, 8 | ) = 9 | b <-> 10 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] >= x[i]); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_global_cardinality_low_up_opt.mzn: -------------------------------------------------------------------------------- 1 | include "global_cardinality.mzn"; 2 | 3 | predicate fzn_global_cardinality_low_up_opt( 4 | array [int] of var opt int: x, 5 | array [int] of int: cover, 6 | array [int] of int: lbound, 7 | array [int] of int: ubound, 8 | ) = 9 | let { 10 | % Set <> to something outside the cover 11 | int: def = if 0 in cover then min(cover) - 1 else 0 endif; 12 | } in global_cardinality([x_i default def | x_i in x], cover, lbound, ubound); 13 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_increasing_set_reif.mzn: -------------------------------------------------------------------------------- 1 | %-----------------------------------------------------------------------------% 2 | % Requires that the array 'x' is in increasing order (duplicates are allowed). 3 | %-----------------------------------------------------------------------------% 4 | 5 | predicate fzn_increasing_set_reif( 6 | array [int] of var set of int: x, 7 | var bool: b, 8 | ) = 9 | b <-> 10 | forall (i in index_set(x) diff {min(index_set(x))}) (x[i - 1] <= x[i]); 11 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_steiner.mzn: -------------------------------------------------------------------------------- 1 | include "tree.mzn"; 2 | 3 | predicate fzn_steiner( 4 | array [int] of int: from, 5 | array [int] of int: to, 6 | array [int] of int: w, 7 | array [int] of var bool: ns, 8 | array [int] of var bool: es, 9 | var int: K, 10 | ) = 11 | let { 12 | var index_set(ns): r; 13 | } in tree(from, to, r, ns, es) /\ 14 | K = sum (e in index_set(es)) (es[e] * w[e]); 15 | 16 | %-----------------------------------------------------------------------------% 17 | -------------------------------------------------------------------------------- /share/minizinc/std/sum_set.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_sum_set.mzn"; 2 | include "fzn_sum_set_reif.mzn"; 3 | 4 | /** @group globals.math 5 | Requires that the sum of the weights \a ws[\p i1]..\a ws[\p iN] equals \a s, 6 | where \a vs[\p i1]..\a vs[\p iN] are the elements appearing in set \a x 7 | */ 8 | predicate sum_set( 9 | array [$$X] of $$Y: vs, 10 | array [$$X] of int: ws, 11 | var set of $$Y: x, 12 | var int: s, 13 | ) = fzn_sum_set(erase_enum(vs), erase_enum(ws), erase_enum(x), s); 14 | -------------------------------------------------------------------------------- /crates/xcsp3-serde/corpus/xcsp3_ex_059.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | x1 x2 x3 x4 5 | 2 5 10 6 | 0..1 1..3 2..3 7 | 8 | 9 | y1 y2 y3 y4 y5 10 | 0 1 2 3 11 | z0 z1 z2 z3 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /share/minizinc/std/at_most_set.mzn: -------------------------------------------------------------------------------- 1 | include "fzn_at_most_set.mzn"; 2 | include "fzn_at_most_set_reif.mzn"; 3 | 4 | %-----------------------------------------------------------------------------% 5 | % Requires at most 'n' variables in 'x' to take the value 'v'. 6 | %-----------------------------------------------------------------------------% 7 | 8 | predicate at_most_set(int: n, array [$X] of var set of $$E: x, set of $$E: v) = 9 | fzn_at_most_set(n, erase_enum(array1d(x)), erase_enum(v)); 10 | -------------------------------------------------------------------------------- /share/minizinc/std/fzn_arg_min_bool.mzn: -------------------------------------------------------------------------------- 1 | predicate fzn_minimum_arg_bool(array [int] of var bool: x, var int: z) = 2 | % general case: min could be 0 or 1 3 | let { 4 | int: l = min(index_set(x)); 5 | int: u = max(index_set(x)); 6 | int: n = u - l + 1; 7 | array [int] of var int: xs = array1d(l..u, [n * x[j] + j | j in l..u]); 8 | var int: Mx = min(xs); 9 | } in forall (j in l..u) (z != j = (Mx < xs[j])); 10 | 11 | %%% only the new decomposition from argmax paper CP2020 submission 12 | --------------------------------------------------------------------------------