Add generic cone property getter

deps/src/normaliz.cpp

@@ -69,6 +69,37 @@ std::vector<std::string> cone_property_names(const libnormaliz::ConeProperties&
     return names;
 }
 
+std::string cone_property_output_type(const std::string& name)
+{
+    switch (libnormaliz::output_type(libnormaliz::toConeProperty(name))) {
+    case libnormaliz::OutputType::Matrix:
+        return "Matrix";
+    case libnormaliz::OutputType::MatrixFloat:
+        return "MatrixFloat";
+    case libnormaliz::OutputType::Vector:
+        return "Vector";
+    case libnormaliz::OutputType::Integer:
+        return "Integer";
+    case libnormaliz::OutputType::GMPInteger:
+        return "GMPInteger";
+    case libnormaliz::OutputType::Rational:
+        return "Rational";
+    case libnormaliz::OutputType::FieldElem:
+        return "FieldElem";
+    case libnormaliz::OutputType::Float:
+        return "Float";
+    case libnormaliz::OutputType::MachineInteger:
+        return "MachineInteger";
+    case libnormaliz::OutputType::Bool:
+        return "Bool";
+    case libnormaliz::OutputType::Complex:
+        return "Complex";
+    case libnormaliz::OutputType::Void:
+        return "Void";
+    }
+    return "Unknown";
+}
+
 template <typename T>
 std::map<libnormaliz::Type::InputType, Matrix<T>>
 to_normaliz_matrix(std::vector<std::string> input_keys,
@@ -276,6 +307,7 @@ JLCXX_MODULE define_module_normaliz(jlcxx::Module& normaliz)
     normaliz.method("_known_cone_properties", []() {
         return cone_property_names(libnormaliz::all_goals());
     });
+    normaliz.method("_cone_property_output_type", cone_property_output_type);
 
     normaliz.method("_GMPCone", [](std::vector<std::string> input_keys,
                                    jlcxx::ArrayRef<Matrix<mpq_class>>

src/Normaliz.jl

@@ -53,6 +53,32 @@ computed_cone_properties(cone::Cone) = _string_vector(_computed_cone_properties(
 is_computed(cone::Cone, property::AbstractString) = _is_computed(cone, property)
 is_computed(cone::Cone, property::Symbol) = is_computed(cone, String(property))
 
+function cone_property(cone::Cone, property::AbstractString)
+    output_type = _cone_property_output_type(property)
+    if output_type == "Matrix"
+        return get_matrix_cone_property(cone, property)
+    elseif output_type == "Vector"
+        return get_vector_cone_property(cone, property)
+    elseif output_type == "Integer"
+        return get_integer_cone_property(cone, property)
+    elseif output_type == "GMPInteger"
+        return get_gmp_integer_cone_property(cone, property)
+    elseif output_type == "Rational"
+        return get_rational_cone_property(cone, property)
+    elseif output_type == "Float"
+        return get_float_cone_property(cone, property)
+    elseif output_type == "MachineInteger"
+        return get_machine_integer_cone_property(cone, property)
+    elseif output_type == "Bool"
+        return get_boolean_cone_property(cone, property)
+    end
+    throw(ArgumentError(
+        "cone property $property has unsupported output type $output_type"))
+end
+
+cone_property(cone::Cone, property::Symbol) =
+    cone_property(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

@@ -161,6 +161,36 @@ end
   @test string(matrix_from_symbol[1, 1]) == string(matrix_from_string[1, 1])
 end
 
+@testset "generic cone property getter" begin
+  xx = Normaliz.NmzMatrix{Normaliz.NmzRational}([1//2 2 ; 3 5])
+  gg = Normaliz.NmzMatrix{Normaliz.NmzRational}([1 1])
+  yy = Normaliz.LongLongCone( Dict( :cone => xx, :grading => gg ) )
+
+  matrix_from_generic = Normaliz.cone_property(yy, :HilbertBasis)
+  matrix_from_typed = Normaliz.get_matrix_cone_property(yy, "HilbertBasis")
+  @test size(matrix_from_generic) == size(matrix_from_typed)
+  @test string(matrix_from_generic[1, 1]) == string(matrix_from_typed[1, 1])
+
+  @test typeof(Normaliz.cone_property(yy, :Grading)) ==
+        typeof(Normaliz.get_vector_cone_property(yy, "Grading"))
+  @test Normaliz.cone_property(yy, :TriangulationDetSum) ==
+        Normaliz.get_integer_cone_property(yy, "TriangulationDetSum")
+  @test string(Normaliz.cone_property(yy, :ExternalIndex)) ==
+        string(Normaliz.get_gmp_integer_cone_property(yy, "ExternalIndex"))
+  @test string(Normaliz.cone_property(yy, :Multiplicity)) ==
+        string(Normaliz.get_rational_cone_property(yy, "Multiplicity"))
+  @test Normaliz.cone_property(yy, :EuclideanVolume) ==
+        Normaliz.get_float_cone_property(yy, "EuclideanVolume")
+  @test Normaliz.cone_property(yy, "EmbeddingDim") ==
+        Normaliz.get_machine_integer_cone_property(yy, "EmbeddingDim")
+  @test Normaliz.cone_property(yy, :IsPointed) ==
+        Normaliz.get_boolean_cone_property(yy, "IsPointed")
+
+  err = @test_throws ArgumentError Normaliz.cone_property(yy, :Triangulation)
+  @test occursin("Triangulation", err.value.msg)
+  @test occursin("Complex", err.value.msg)
+end
+
 # TODO: reactivate these tests once Renf support is back
 #@testset "basic renf test" begin
 #  r = Normaliz.RenfClass("a4-5a2+5", "a", "1.9021+/-0.01")