double.GetHashCode()

public override int GetHashCode()
        {
            return HashUtility.CombineHash(
                position.GetHashCode(),
                startTime.GetHashCode(),
                endTime.GetHashCode()
            );
        }

public override int GetHashCode()
        {
            var hashCode = -884009331;
#pragma warning disable RECS0025 // Non-readonly field referenced in 'GetHashCode()'
            hashCode = hashCode * -1521134295 + a.GetHashCode();
            hashCode = hashCode * -1521134295 + b.GetHashCode();
            hashCode = hashCode * -1521134295 + c.GetHashCode();
            hashCode = hashCode * -1521134295 + d.GetHashCode();
            hashCode = hashCode * -1521134295 + tx.GetHashCode();
            hashCode = hashCode * -1521134295 + ty.GetHashCode();
#pragma warning restore RECS0025 // Non-readonly field referenced in 'GetHashCode()'
            return hashCode;
        }

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (kindCase_ == KindOneofCase.NullValue) hash ^= NullValue.GetHashCode();
      if (kindCase_ == KindOneofCase.NumberValue) hash ^= NumberValue.GetHashCode();
      if (kindCase_ == KindOneofCase.StringValue) hash ^= StringValue.GetHashCode();
      if (kindCase_ == KindOneofCase.BoolValue) hash ^= BoolValue.GetHashCode();
      if (kindCase_ == KindOneofCase.StructValue) hash ^= StructValue.GetHashCode();
      if (kindCase_ == KindOneofCase.ListValue) hash ^= ListValue.GetHashCode();
      hash ^= (int) kindCase_;
      return hash;
    }

[Pure]
        [PublicAPI]
        public override int GetHashCode()
        {
            // Overflow is fine, just wrap
            unchecked
            {
                var hash = (int)2166136261;
                for (var i = 0; i < this.Rows; i++)
                {
                    for (var j = 0; j < this.Columns; j++)
                    {
                        hash = (hash * 16777619) ^ this.GetAt(i, j).GetHashCode();
                    }
                }

                return hash;
            }
        }

public override int GetHashCode()
        {
            return this.x.GetHashCode() ^ this.y.GetHashCode();
        }

public override int GetHashCode()
      {
         return m_Data.GetHashCode();
      }

int GetTimeRangeHash()
        {
            double start = double.MaxValue, end = double.MinValue;
            foreach (var marker in GetMarkers())
            {
                if (!(marker is INotification))
                {
                    continue;
                }

                if (marker.time < start)
                    start = marker.time;
                if (marker.time > end)
                    end = marker.time;
            }

            return start.GetHashCode().CombineHash(end.GetHashCode());
        }

public override int GetHashCode() => Hertz.GetHashCode();

public override int GetHashCode()
        {
#pragma warning disable RECS0025 // Non-readonly field referenced in 'GetHashCode()'
            return (x.GetHashCode() << 16) ^ y.GetHashCode();
#pragma warning restore RECS0025 // Non-readonly field referenced in 'GetHashCode()'
        }

public int GetHashCode(double x) => x.GetHashCode();

public override int GetHashCode()
        {
            int hash = 19;
            hash = hash * 31 + x.GetHashCode();
            hash = hash * 31 + y.GetHashCode();

            return hash;
        }

public override int GetHashCode()
        {
            unchecked
            {
                return (X.GetHashCode() * 397) ^ Y.GetHashCode();
            }
        }

public override int GetHashCode()
      {
        return m_R.GetHashCode() + m_Theta.GetHashCode();
      }

[PublicAPI]
        public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                var hash = (int)2166136261;
                hash = (hash * 16777619) ^ this.X.GetHashCode();
                hash = (hash * 16777619) ^ this.Y.GetHashCode();
                hash = (hash * 16777619) ^ this.Z.GetHashCode();
                hash = (hash * 16777619) ^ this.W.GetHashCode();  
                return hash;
            }
        }

public override int GetHashCode() => Nanoseconds.GetHashCode();

int ComputeDirtyHash()
        {
            return time.GetHashCode();
        }

public override int GetHashCode()
		{
			unchecked
			{
				var hashCode = Lareplacedude.GetHashCode();
				hashCode = (hashCode * 397) ^ Longitude.GetHashCode();
				return hashCode;
			}
		}

public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode();
        }

public override int GetHashCode()
		{
			return this.x.GetHashCode() ^ this.y.GetHashCode() << 2;
		}

public override int GetHashCode()
        {
            var hashCode = -1285340573;

            hashCode = hashCode * -1521134295 + pointA.GetHashCode();
            hashCode = hashCode * -1521134295 + pointB.GetHashCode();
            hashCode = hashCode * -1521134295 + distance.GetHashCode();

            return hashCode;
        }

public override int GetHashCode()
        {
            unchecked
            {
                int hash = 17;
                hash = hash * 31 + (int) type;
                hash = hash * 31 + stringValue == null ? 0 : stringValue.GetHashCode();
                hash = hash * 31 + numberValue.GetHashCode();
                return hash;
            }
        }

public override int GetHashCode()
        {
            return Start.GetHashCode() ^ Length.GetHashCode() ^ Confidence.GetHashCode() ^ Value.GetHashCode();
        }

public override int GetHashCode()
        {
            unchecked
            {
                int result = this.Color.GetHashCode();
                result = (result * 397) ^ this.Thickness.GetHashCode();
                result = (result * 397) ^ this.LineStyle.GetHashCode();
                result = (result * 397) ^ this.LineJoin.GetHashCode();
                return result;
            }
        }

public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = _a.GetHashCode();
                hashCode = (hashCode * 397) ^ _b.GetHashCode();
                hashCode = (hashCode * 397) ^ _c.GetHashCode();
                hashCode = (hashCode * 397) ^ _d.GetHashCode();
                hashCode = (hashCode * 397) ^ _e.GetHashCode();
                hashCode = (hashCode * 397) ^ _f.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            unchecked
            {
                var hashCode = Name != null ? Name.GetHashCode() : 0;
                hashCode = hashCode * 397 ^ Size.GetHashCode();
                hashCode = hashCode * 397 ^ (int) Style;
                hashCode = hashCode * 397 ^ (int) FontEncoding;
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            if (IsEmpty)
                return 0;

            return xMin.GetHashCode() ^
                    width.GetHashCode() ^
                    yMin.GetHashCode() ^
                    height.GetHashCode();
        }

public override int GetHashCode()
		{
			return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
		}

public override int GetHashCode() => m_Lat.GetHashCode() ^ m_Lng.GetHashCode();

public override int GetHashCode()
        {
            var hashCode = 1753786285;
            hashCode = hashCode * -1521134295 + Type.GetHashCode();
            hashCode = hashCode * -1521134295 + EqualityComparer<BigInteger>.Default.GetHashCode(IntValue);
            hashCode = hashCode * -1521134295 + DoubleValue.GetHashCode();
            return hashCode;
        }

public override int GetHashCode() => unchecked ((Start.GetHashCode() * 397) ^ End.GetHashCode());

[PublicAPI]
        public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                var hash = (int)2166136261;
                hash = (hash * 16777619) ^ this.X.GetHashCode();
                hash = (hash * 16777619) ^ this.Y.GetHashCode();  
                return hash;
            }
        }

public override int GetHashCode() => Value.GetHashCode() ^ Bookmark.GetHashCode();

[PublicAPI]
        public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                var hash = (int)2166136261;
                hash = (hash * 16777619) ^ this.X.GetHashCode();
                hash = (hash * 16777619) ^ this.Y.GetHashCode();
                hash = (hash * 16777619) ^ this.Z.GetHashCode();  
                return hash;
            }
        }

public override int GetHashCode() => Value.GetHashCode();

public override int GetHashCode()
        {
            return HashUtility.CombineHash(
                markerRegion.GetHashCode(),
                timelineRegion.GetHashCode(),
                startTime.GetHashCode(),
                endTime.GetHashCode()
            );
        }

public override int GetHashCode()
        {
            var hashCode = 1861411795;
            hashCode = hashCode * -1521134295 + X.GetHashCode();
            hashCode = hashCode * -1521134295 + Y.GetHashCode();
            return hashCode;
        }

internal int Hash()
        {
            return HashUtility.CombineHash(m_Start.GetHashCode(),
                m_Duration.GetHashCode(),
                m_TimeScale.GetHashCode(),
                m_ClipIn.GetHashCode(),
                ((int)m_PreExtrapolationMode).GetHashCode(),
                ((int)m_PostExtrapolationMode).GetHashCode());
        }

public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = Estimation.GetHashCode();
                hashCode = (hashCode * 397) ^ Lower.GetHashCode();
                hashCode = (hashCode * 397) ^ Upper.GetHashCode();
                hashCode = (hashCode * 397) ^ ConfidenceLevel.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            return Lareplacedude.GetHashCode() ^ Longitude.GetHashCode();
        }

public override int GetHashCode()
        {
            if (this.IsDouble)
                return this.Double.Value.GetHashCode();
            if (this.IsInteger)
                return this.Integer.Value.GetHashCode();
            if (this.IsBolean)
                return this.Bolean.Value.GetHashCode();
            return this.String.GetHashCode();
        }

public override int GetHashCode()
        {
            return RedMultiplier.GetHashCode() ^ GreenMultiplier.GetHashCode() ^ BlueMultiplier.GetHashCode();
        }

public override int GetHashCode()
        {
            return m_Data.GetHashCode();
        }

public override int GetHashCode()
        {
            var hashCode = -1064806749;

#pragma warning disable RECS0025 // Non-readonly field referenced in 'GetHashCode()'
            hashCode = hashCode * -1521134295 + left.GetHashCode();
            hashCode = hashCode * -1521134295 + bottom.GetHashCode();
            hashCode = hashCode * -1521134295 + right.GetHashCode();
            hashCode = hashCode * -1521134295 + top.GetHashCode();
#pragma warning restore RECS0025 // Non-readonly field referenced in 'GetHashCode()'

            return hashCode;
        }

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Value != 0D) hash ^= Value.GetHashCode();
      return hash;
    }

public override int GetHashCode() => ratio.GetHashCode();

public override int GetHashCode()
        {
            switch (FloatType)
            {
                case BssomFloatType.Single:
                    return GetFloat32().GetHashCode();
                default://case BssomFloatType.Double:
                    return GetFloat64().GetHashCode();
            }
        }

public override int GetHashCode()
        {
            return this.x.GetHashCode() ^ this.y.GetHashCode() << 2;
        }

public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = Value.GetHashCode();
                hashCode = (hashCode * 397) ^ Max.GetHashCode();
                hashCode = (hashCode * 397) ^ Min.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
            {
                unchecked
                {
                    var hashCode = A.GetHashCode();
                    hashCode = (hashCode * 397) ^ R.GetHashCode();
                    hashCode = (hashCode * 397) ^ G.GetHashCode();
                    hashCode = (hashCode * 397) ^ B.GetHashCode();
                    return hashCode;
                }
            }

public override int GetHashCode() => this.InternalDecrypt().GetHashCode();

See More Examples