Allow querying known and computed cone properties

deps/src/normaliz.cpp

@@ -56,6 +56,19 @@ void set_bigint_from_nmzinteger(jl_value_t* result, mpz_class& value)
     mpz_set(julia_bigint_data_mutable(result), value.get_mpz_t());
 }
 
+std::vector<std::string> cone_property_names(const libnormaliz::ConeProperties& properties)
+{
+    std::vector<std::string> names;
+    for (int i = 0; i < libnormaliz::ConeProperty::EnumSize; ++i) {
+        auto property = static_cast<libnormaliz::ConeProperty::Enum>(i);
+        if (properties.test(property) &&
+            libnormaliz::output_type(property) != libnormaliz::OutputType::Void) {
+            names.push_back(libnormaliz::toString(property));
+        }
+    }
+    return names;
+}
+
 template <typename T>
 std::map<libnormaliz::Type::InputType, Matrix<T>>
 to_normaliz_matrix(std::vector<std::string> input_keys,
@@ -251,8 +264,19 @@ JLCXX_MODULE define_module_normaliz(jlcxx::Module& normaliz)
                                    return C.getBooleanConeProperty(
                                        libnormaliz::toConeProperty(s));
                                });
+                wrapped.method("_computed_cone_properties", [](WrappedT& C) {
+                    return cone_property_names(C.getIsComputed());
+                });
+                wrapped.method("_is_computed", [](WrappedT& C,
+                                                  const std::string& s) {
+                    return C.isComputed(libnormaliz::toConeProperty(s));
+                });
             });
 
+    normaliz.method("_known_cone_properties", []() {
+        return cone_property_names(libnormaliz::all_goals());
+    });
+
     normaliz.method("_GMPCone", [](std::vector<std::string> input_keys,
                                    jlcxx::ArrayRef<Matrix<mpq_class>>
                                        input_matrices) {

src/Normaliz.jl

@@ -46,6 +46,13 @@ Base.show(io::IO,x::NmzInteger) = print(io,to_string(x))
 Base.show(io::IO,x::NmzRational) = print(io,to_string(x))
 Base.show(io::IO,x::Cone) = print(io,"Normaliz cone")
 
+_string_vector(x) = String.(collect(x))
+
+known_cone_properties() = _string_vector(_known_cone_properties())
+computed_cone_properties(cone::Cone) = _string_vector(_computed_cone_properties(cone))
+is_computed(cone::Cone, property::AbstractString) = _is_computed(cone, property)
+is_computed(cone::Cone, property::Symbol) = is_computed(cone, String(property))
+
 get_matrix_cone_property(cone, property::Symbol) =
     get_matrix_cone_property(cone, String(property))
 get_vector_cone_property(cone, property::Symbol) =

test/runtests.jl

@@ -113,6 +113,26 @@ end
   Normaliz.get_matrix_cone_property( yy, "SupportHyperplanes" )
 end
 
+@testset "cone property queries" begin
+  known_properties = Normaliz.known_cone_properties()
+  @test known_properties isa Vector{String}
+  @test "ExtremeRays" in known_properties
+  @test "Multiplicity" in known_properties
+  @test "IsPointed" in known_properties
+  @test !("DefaultMode" in known_properties)
+
+  xx = Normaliz.NmzMatrix{Normaliz.NmzRational}([1 2 ; 3 5])
+  yy = Normaliz.GMPCone( Dict( :cone => xx ) )
+
+  @test !Normaliz.is_computed(yy, :ExtremeRays)
+  Normaliz.get_matrix_cone_property(yy, :ExtremeRays)
+  computed_properties = Normaliz.computed_cone_properties(yy)
+  @test computed_properties isa Vector{String}
+  @test "ExtremeRays" in computed_properties
+  @test Normaliz.is_computed(yy, "ExtremeRays")
+  @test Normaliz.is_computed(yy, :ExtremeRays)
+end
+
 @testset "cone properties accept symbols" begin
   xx = Normaliz.NmzMatrix{Normaliz.NmzRational}([1//2 2 ; 3 5])
   gg = Normaliz.NmzMatrix{Normaliz.NmzRational}([1 1])