<!DOCTYPE html>
<html>

  <script>
    'use strict';

    function PrimeField(n)
    {
        this.elements = [];
        for (var q = 0; q < n; q++)
            this.elements.push(q);
        this.order = n;

        this.add = function (x, y)
        {
            return (x + y) % this.order;
        };

        this.mult = function (x, y)
        {
            return (x * y) % this.order;
        };

        this.isElement = function (x)
        {
            return x > -1 && x < this.order;
        };

        // is this closed? so x+y and x.y are elements for all x and y
        this.isClosed = function ()
        {
            for (var x = 0; x < this.order; x++)
                for (var y = 0; y < this.order; y++)
                { // closed under addition
                    if (!this.isElement(this.add(x, y)))
                        return false;
                }
            for (var x = 0; x < this.order; x++)
                for (var y = 0; y < this.order; y++)
                { // closed under multiplication
                    if (!this.isElement(this.mult(x, y)))
                        return false;
                }
            return true;
        };

        // is this associative?
        this.isAssoc = function ()
        {
            for (var x = 0; x < this.order; x++)
                for (var y = 0; y < this.order; y++)
                    for (var z = 0; z < this.order; z++)
                    { // for all x,y,z, x+(y+z) = (x+y)+z
                        if (this.add(x, this.add(y, z)) !== this.add(this.add(x, y), z))
                            return false;
                    }
            for (var x = 0; x < this.order; x++)
                for (var y = 0; y < this.order; y++)
                    for (var z = 0; z < this.order; z++)
                    { // for all x,y,z, x.(y.z) = (x.y).z
                        if (this.mult(x, this.mult(y, z)) !== this.mult(this.mult(x, y), z))
                            return false;
                    }
            return true;
        };

        // is this commutative?
        this.isCommut = function ()
        {
            for (var x = 0; x < this.order; x++)
                for (var y = 0; y < this.order; y++)

                { // for all x,y,z, x+(y+z) = (x+y)+z
                    if (this.add(x, y) !== this.add(y, x))
                        return false;
                }
            for (var x = 0; x < this.order; x++)
                for (var y = 0; y < this.order; y++)

                { // for all x,y,z, x.(y.z) = (x.y).z
                    if (this.mult(x, y) !== this.mult(y, x))
                        return false;
                }
            return true;
        };

        // has additive identity
        this.hasAddIdent = function ()
        {
            for (var x = 0; x < this.order; x++)
            {
                var found = true;
                for (var y = 0; y < this.order; y++)
                    if (this.add(x, y) !== y)
                        found = false;
                if (found)
                    return true;
            }
            return false;
        };

        // has multiplicative identity
        this.hasMultIdent = function ()
        {
            for (var x = 0; x < this.order; x++)
            {
                var found = true;
                for (var y = 0; y < this.order; y++)
                    if (this.mult(x, y) !== y)
                        found = false;
                if (found)
                    return true;
            }
            return false;
        };

        this.hasIdentities = function ()
        {
            return this.hasAddIdent() && this.hasMultIdent();
        };

// has additive inverse
        this.hasAddInverse = function ()
        {
            for (var x = 0; x < this.order; x++) // for each element x
            {
                var found = false;
                for (var y = 0; y < this.order; y++) // y is candidate inverse
                    if (this.add(x, y) === 0)
                    {
                        found = true; // got it
                        break; // stop looking
                    }
                if (!found) // failed to find inverse
                    return false;
            }
            return true; // all x have an inverse
        };



        // has multiplicative inverse
        this.hasMultInverse = function ()
        {
            for (var x = 1; x < this.order; x++) // for each element x
            {
                var found = false;
                for (var y = 0; y < this.order; y++) // y is candidate inverse
                    if (this.mult(x, y) === 1)
                    {
                        found = true; // got it
                        break; // stop looking
                    }
                if (!found) // failed to find inverse
                {
                    document.write(x);
                    return false;
                }
            }
            return true; // all x have an inverse
        };

        // has inverses
        this.hasInverses = function ()
        {
            return this.hasAddInverse() && this.hasMultInverse();
        };

        // distributive
        this.isDistributive = function ()
        {
            for (var x = 0; x < this.order; x++) // for each element x
                for (var y = 0; y < this.order; y++)
                    for (var z = 0; z < this.order; z++)
                        if (this.mult(x, this.add(y, z)) !== this.add(this.mult(x, y), this.mult(x, z)))
                            return false;

            return true;
        };

    }

    function show(x)
    {
        if (x === 0)
            document.write("O");
        else {
            var num = 0x2460 + x - 1;
            document.write(String.fromCharCode(num));
        }
    }

    var G5 = new PrimeField(5);


    document.write(G5.isDistributive());


  </script>
  <head>
    <title>Field</title>
  </head>
  <body>
  </body>
</html>