Quelle DummyImplementations.gi Sprache: unbekannt

# SPDX-License-Identifier: GPL-2.0-or-later
# CAP: Categories, Algorithms, Programming
#
# Implementations
#

## dummy rings

BindGlobal( "TheFamilyOfDummyRings",
        NewFamily( "TheFamilyOfDummyRings" ) );

CAP_INTERNAL_DUMMY_RING_COUNTER := 1;

InstallGlobalFunction( DummyRing, function( )
  local ring_filter, ring_element_filter, name, ring;

    ring_filter := NewFilter( "DummyRingFilter", IsDummyRing );
    ring_element_filter := NewFilter( "DummyRingElementFilter", IsDummyRingElement );

    name := Concatenation( "Dummy ring ", String( CAP_INTERNAL_DUMMY_RING_COUNTER ) );
    CAP_INTERNAL_DUMMY_RING_COUNTER := CAP_INTERNAL_DUMMY_RING_COUNTER + 1;

    ring := CreateGapObjectWithAttributes( NewType( TheFamilyOfDummyRings, IsAttributeStoringRep and ring_filter ),
        Name, name,
        String, name,
        RingFilter, ring_filter,
        RingElementFilter, ring_element_filter
    );

    CapJitAddTypeSignature( "+", [ ring_element_filter, ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "ZeroImmutable", [ ring_filter ], ring_element_filter );
    CapJitAddTypeSignature( "AdditiveInverseSameMutability", [ ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "*", [ ring_element_filter, ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "OneImmutable", [ ring_filter ], ring_element_filter );

    return ring;

end );

## dummy commutative rings

BindGlobal( "TheFamilyOfDummyCommutativeRings",
        NewFamily( "TheFamilyOfDummyCommutativeRings" ) );

CAP_INTERNAL_DUMMY_COMMUTATIVE_RING_COUNTER := 1;

InstallGlobalFunction( DummyCommutativeRing, function( )
  local ring_filter, ring_element_filter, name, ring;

    ring_filter := NewFilter( "DummyCommutativeRingFilter", IsDummyCommutativeRing );
    ring_element_filter := NewFilter( "DummyCommutativeRingElementFilter", IsDummyCommutativeRingElement );

    name := Concatenation( "Dummy commutative ring ", String( CAP_INTERNAL_DUMMY_COMMUTATIVE_RING_COUNTER ) );
    CAP_INTERNAL_DUMMY_COMMUTATIVE_RING_COUNTER := CAP_INTERNAL_DUMMY_COMMUTATIVE_RING_COUNTER + 1;

    ring := CreateGapObjectWithAttributes( NewType( TheFamilyOfDummyCommutativeRings, IsAttributeStoringRep and ring_filter ),
        Name, name,
        String, name,
        RingFilter, ring_filter,
        RingElementFilter, ring_element_filter,
        IsCommutative, true
    );

    CapJitAddTypeSignature( "+", [ ring_element_filter, ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "ZeroImmutable", [ ring_filter ], ring_element_filter );
    CapJitAddTypeSignature( "AdditiveInverseSameMutability", [ ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "*", [ ring_element_filter, ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "OneImmutable", [ ring_filter ], ring_element_filter );

    return ring;

end );

## dummy fields

BindGlobal( "TheFamilyOfDummyFields",
        NewFamily( "TheFamilyOfDummyFields" ) );

CAP_INTERNAL_DUMMY_FIELD_COUNTER := 1;

InstallGlobalFunction( DummyField, function( )
  local ring_filter, ring_element_filter, name, ring;

    ring_filter := NewFilter( "DummyFieldFilter", IsDummyField );
    ring_element_filter := NewFilter( "DummyFieldElementFilter", IsDummyFieldElement );

    name := Concatenation( "Dummy field ", String( CAP_INTERNAL_DUMMY_FIELD_COUNTER ) );
    CAP_INTERNAL_DUMMY_FIELD_COUNTER := CAP_INTERNAL_DUMMY_FIELD_COUNTER + 1;

    ring := CreateGapObjectWithAttributes( NewType( TheFamilyOfDummyFields, IsAttributeStoringRep and ring_filter ),
        Name, name,
        String, name,
        RingFilter, ring_filter,
        RingElementFilter, ring_element_filter,
        IsField, true
    );

    CapJitAddTypeSignature( "+", [ ring_element_filter, ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "ZeroImmutable", [ ring_filter ], ring_element_filter );
    CapJitAddTypeSignature( "AdditiveInverseSameMutability", [ ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "*", [ ring_element_filter, ring_element_filter ], ring_element_filter );
    CapJitAddTypeSignature( "OneImmutable", [ ring_filter ], ring_element_filter );

    return ring;

end );

## dummy categories

##
InstallMethod( DummyCategory,
        "for a record of options",
        [ IsRecord ],

  FunctionWithNamedArguments(
  [
    [ "FinalizeCategory", true ],
  ],
  function( CAP_NAMED_ARGUMENTS, options )
    local category_constructor_options, dummy_function, C, operation_name;

    category_constructor_options := ShallowCopy( options );
    category_constructor_options.category_filter := IsDummyCategory;
    category_constructor_options.category_object_filter := IsDummyCategoryObject;
    category_constructor_options.category_morphism_filter := IsDummyCategoryMorphism;
    category_constructor_options.is_computable := "IsCongruentForMorphisms" in options.list_of_operations_to_install;
    category_constructor_options.supports_empty_limits := true;

    if "ObjectConstructor" in options.list_of_operations_to_install then

        category_constructor_options.object_constructor := function ( cat, object_datum )

            Error( "this is a dummy category without actual implementation" );

        end;

    fi;

    if "MorphismConstructor" in options.list_of_operations_to_install then

        category_constructor_options.morphism_constructor := function ( cat, source, morphism_datum, range )

            Error( "this is a dummy category without actual implementation" );

        end;

    fi;

    if "ObjectDatum" in options.list_of_operations_to_install then

        category_constructor_options.object_datum := function ( cat, object )

            Error( "this is a dummy category without actual implementation" );

        end;

    fi;

    if "MorphismDatum" in options.list_of_operations_to_install then

        category_constructor_options.morphism_datum := function ( cat, morphism )

            Error( "this is a dummy category without actual implementation" );

        end;

    fi;

    dummy_function := { operation_name, dummy } -> Pair( """
        function ( input_arguments... )

            Error( "this is a dummy category without actual implementation" );

        end
    """, 1 );

    category_constructor_options.create_func_bool := dummy_function;
    category_constructor_options.create_func_object := dummy_function;
    category_constructor_options.create_func_morphism := dummy_function;
    category_constructor_options.create_func_list_of_objects := dummy_function;

    C := CategoryConstructor( category_constructor_options );

    if CAP_NAMED_ARGUMENTS.FinalizeCategory then

        Finalize( C );

    fi;

    for operation_name in options.list_of_operations_to_install do

        if not CanCompute( C, operation_name ) then

            Print( "WARNING: The dummy category cannot compute ", operation_name, ", probably because the operation is not supported by CategoryConstructor yet.\n" );

        fi;

    od;

    return C;

end ) );

Quelle DummyImplementations.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.31 Sekunden (vorverarbeitet) ]