package odin-algebra:rational
Source

⌘K
Ctrl+K
or
/

    Types

    Rational ¶
    Source

    Rational :: struct($T: typeid, $ST: typeid) {
	… // See source for fields
}
     

    This structure represents a rational field over some underling ring.

    Inputs:
    $T: the type of the numerator/denominator $ST: the type of the algebraic structure used to operate on the numerator/denominator

    Example: 
    Rational(i64, ring.Ring(i64))
    Related Procedures With Parameters
    Related Procedures With Returns

    RationalGeneratorInfo ¶
    Source

    RationalGeneratorInfo :: struct($T: typeid, $ST: typeid) {
	… // See source for fields
}

    Constants

    This section is empty.

    Variables

    This section is empty.

    Procedures

    add_ident_numeric ¶
    Source

    add_ident_numeric :: proc($T: typeid, algebraic_structure: $ST) -> Rational($T=typeid, $ST) {…}

    add_ident_ring ¶
    Source

    add_ident_ring :: proc($T: typeid, algebraic_structure: $ST) -> Rational($T=typeid, $ST) {…}

    add_numeric ¶
    Source

    add_numeric :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    add_ring ¶
    Source

    add_ring :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    delete_generator ¶
    Source

    delete_generator :: proc(gen: prop_test.Generator($T=Rational($T, $ST))) {…}

    delete_rational_base ¶
    Source

    delete_rational_base :: proc(r: Rational($T, $ST)) {…}

    delete_rational_commutative_ring ¶
    Source

    delete_rational_commutative_ring :: proc(cr: ring.CommutativeRing($T=Rational($T, $ST))) {…}

    delete_rational_euclidean_ring ¶
    Source

    delete_rational_euclidean_ring :: proc(er: euclidean_ring.EuclideanRing($T=Rational($T, $ST))) {…}

    delete_rational_field ¶
    Source

    delete_rational_field :: proc(f: field.Field($T=Rational($T, $ST))) {…}

    delete_rational_integral_domain ¶
    Source

    delete_rational_integral_domain :: proc(id: integral_domain.IntegralDomain($T=Rational($T, $ST))) {…}

    delete_rational_numeric ¶
    Source

    delete_rational_numeric :: proc(r: Rational($T, $ST)) {…}

    delete_rational_ring ¶
    Source

    delete_rational_ring :: proc(r: ring.Ring($T=Rational($T, $ST))) {…}

    div_numeric ¶
    Source

    div_numeric :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    div_ring ¶
    Source

    div_ring :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    eq_base ¶
    Source

    eq_base :: proc(l: Rational($T, $ST), r: Rational($T, $ST)) -> bool {…}

    eq_numeric ¶
    Source

    eq_numeric :: proc(l: Rational($T, $ST), r: Rational($T, $ST)) -> bool {…}

    make_generator ¶
    Source

    make_generator :: proc(coefficient_generator: prop_test.Generator($T), coefficient_algebraic_structure: $ST) -> prop_test.Generator($T=Rational($T, $ST)) {…}
     

    makes a generator for rationals given a generator of the numerator and denominator used for property based testing of rationals

    make_rational ¶
    Source

    make_rational :: proc(numerator: $T, denominator: $T, algebraic_structure: $ST) -> Rational($T, $ST) {…}
     

    used to make a rational from a numerator and denominator does not clone the numerator and denominator

    make_rational_base ¶
    Source

    make_rational_base :: proc($T: typeid, coeffiencet_structure: $ST) -> base.Base($T=Rational($T=typeid, $ST)) {…}
     

    makes an base structure for a rational given the numerator/denominator base structure

    make_rational_commutative_ring ¶
    Source

    make_rational_commutative_ring :: proc($T: typeid, coeffiencet_structure: $ST) -> ring.CommutativeRing($T=Rational($T=typeid, $ST)) {…}

    make_rational_euclidean_ring ¶
    Source

    make_rational_euclidean_ring :: proc($T: typeid, coeffiencet_structure: $ST) -> euclidean_ring.EuclideanRing($T=Rational($T=typeid, $ST)) {…}
     

    makes an euclidean ring structure for a rational given the numerator/denominator commutative ring structure.

    make_rational_field ¶
    Source

    make_rational_field :: proc($T: typeid, coeffiencet_structure: $ST) -> field.Field($T=Rational($T=typeid, $ST)) {…}
     

    makes an field structure for a rational given the numerator/denominator commutative ring structure.

    make_rational_integral_domain ¶
    Source

    make_rational_integral_domain :: proc($T: typeid, coeffiencet_structure: $ST) -> integral_domain.IntegralDomain($T=Rational($T=typeid, $ST)) {…}
     

    makes an integral domain structure for a rational given the numerator/denominator commutative ring structure.

    make_rational_ring ¶
    Source

    make_rational_ring :: proc($T: typeid, coeffiencet_structure: $ST) -> ring.Ring($T=Rational($T=typeid, $ST)) {…}
     

    makes an ring structure for a rational given the numerator/denominator ring structure.

    mul_ident_numeric ¶
    Source

    mul_ident_numeric :: proc($T: typeid, algebraic_structure: $ST) -> Rational($T=typeid, $ST) {…}

    mul_ident_ring ¶
    Source

    mul_ident_ring :: proc($T: typeid, algebraic_structure: $ST) -> Rational($T=typeid, $ST) {…}

    mul_inverse ¶
    Source

    mul_inverse :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST)) {…}

    mul_numeric ¶
    Source

    mul_numeric :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    mul_ring ¶
    Source

    mul_ring :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    neg_numeric ¶
    Source

    neg_numeric :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST)) {…}

    neg_ring ¶
    Source

    neg_ring :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST)) {…}

    sb_print_rational_base ¶
    Source

    sb_print_rational_base :: proc(builder: ^strings.Builder, r: Rational($T, $ST)) {…}

    sb_print_rational_numeric ¶
    Source

    sb_print_rational_numeric :: proc(builder: ^strings.Builder, r: Rational($T, $ST)) {…}

    set_base ¶
    Source

    set_base :: proc(l: ^Rational($T, $ST), r: Rational($T, $ST)) {…}

    set_numeric ¶
    Source

    set_numeric :: proc(l: ^Rational($T, $ST), r: Rational($T, $ST)) {…}

    simplify ¶
    Source

    simplify :: proc(r: ^Rational($T, $ST)) {…}
     

    if the underling structure is a euclidean ring simplifies the fraction by computing the gcd and dividing both numerator and denominator.

    sub_numeric ¶
    Source

    sub_numeric :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    sub_ring ¶
    Source

    sub_ring :: proc(ans: ^Rational($T, $ST), l: Rational($T, $ST), r: Rational($T, $ST)) {…}

    test_rational_over_i64_euclidean_ring_axioms ¶
    Source

    test_rational_over_i64_euclidean_ring_axioms :: proc(t: ^testing.T) {…}

    test_rational_over_i64_field_axioms ¶
    Source

    test_rational_over_i64_field_axioms :: proc(t: ^testing.T) {…}

    test_rational_over_i64_integral_domain_axioms ¶
    Source

    test_rational_over_i64_integral_domain_axioms :: proc(t: ^testing.T) {…}

    test_rational_over_i64_integral_domain_safety_axioms ¶
    Source

    test_rational_over_i64_integral_domain_safety_axioms :: proc(t: ^testing.T) {…}

    Procedure Groups

    add ¶
    Source

    add :: proc{
	add_ring,
	add_numeric,
}

    add_ident ¶
    Source

    add_ident :: proc{
	add_ident_ring,
	add_ident_numeric,
}

    delete_rational ¶
    Source

    delete_rational :: proc{
	delete_rational_base,
	delete_rational_numeric,
}

    div ¶
    Source

    div :: proc{
	div_ring,
	div_numeric,
}

    eq ¶
    Source

    eq :: proc{
	eq_base,
	eq_numeric,
}

    mul ¶
    Source

    mul :: proc{
	mul_ring,
	mul_numeric,
}

    mul_ident ¶
    Source

    mul_ident :: proc{
	mul_ident_ring,
	mul_ident_numeric,
}

    neg ¶
    Source

    neg :: proc{
	neg_ring,
	neg_numeric,
}

    sb_print_rational ¶
    Source

    sb_print_rational :: proc{
	sb_print_rational_base,
	sb_print_rational_numeric,
}

    set ¶
    Source

    set :: proc{
	set_base,
	set_numeric,
}

    sub ¶
    Source

    sub :: proc{
	sub_ring,
	sub_numeric,
}

    Source Files

    Generation Information

    Generated with odin version dev-2025-04 (vendor "odin") Linux_amd64 @ 2025-05-13 09:15:55.506976859 +0000 UTC