ooples
diff --git a/‎src/Enums/NormalizationMethod.cs‎
Lines changed: 34 additions & 5 deletions b/‎src/Enums/NormalizationMethod.cs‎
Lines changed: 34 additions & 5 deletions
diff --git a/‎src/Enums/OutputDistribution.cs‎
Lines changed: 52 additions & 0 deletions b/‎src/Enums/OutputDistribution.cs‎
Lines changed: 52 additions & 0 deletions
diff --git a/‎src/Models/NormalizationParameters.cs‎
Lines changed: 103 additions & 8 deletions b/‎src/Models/NormalizationParameters.cs‎
Lines changed: 103 additions & 8 deletions
@@ -148,13 +148,42 @@ public enum NormalizationMethod
     /// </summary>
     /// <remarks>
     /// <para>
-    /// <b>For Beginners:</b> Robust Scaling is designed to handle data with outliers (extreme values that don't 
-    /// follow the pattern). Instead of using the minimum and maximum values (which can be skewed by outliers), 
-    /// it uses the median and quartiles. It's like saying "ignore the extremely tall and short people when 
-    /// standardizing heights." This is useful when your data contains unusual values that shouldn't influence 
+    /// <b>For Beginners:</b> Robust Scaling is designed to handle data with outliers (extreme values that don't
+    /// follow the pattern). Instead of using the minimum and maximum values (which can be skewed by outliers),
+    /// it uses the median and quartiles. It's like saying "ignore the extremely tall and short people when
+    /// standardizing heights." This is useful when your data contains unusual values that shouldn't influence
     /// the overall scaling.
     /// Formula: (x - median) / (Q3 - Q1) where Q1 is the 25th percentile and Q3 is the 75th percentile
     /// </para>
     /// </remarks>
-    RobustScaling
+    RobustScaling,
+
+    /// <summary>
+    /// Scales features to the range [-1, 1] by dividing by the maximum absolute value.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> MaxAbsScaler is like MinMax scaling, but instead of using both the minimum and
+    /// maximum values, it only uses the maximum absolute value (the largest value ignoring signs). This
+    /// method preserves zeros and the sign of values, which is important for sparse data where many values
+    /// are zero. For example, if your largest value is 100 and smallest is -50, everything gets divided by 100,
+    /// so results fall between -1 and 1.
+    /// Formula: x / max(|x|)
+    /// </para>
+    /// </remarks>
+    MaxAbsScaler,
+
+    /// <summary>
+    /// Transforms features to follow a uniform or normal distribution using quantiles.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> QuantileTransformer is a powerful technique that changes your data's distribution
+    /// to be either uniform (flat, where all ranges have equal numbers of values) or normal (bell-shaped).
+    /// It works by ranking values and mapping them to a target distribution. This is extremely effective at
+    /// handling outliers because it spreads them out across the distribution. Think of it as redistributing
+    /// your data so that it matches a desired pattern, regardless of the original distribution.
+    /// </para>
+    /// </remarks>
+    QuantileTransformer
 }
@@ -0,0 +1,52 @@
+namespace AiDotNet.Enums;
+
+/// <summary>
+/// Specifies the target distribution for quantile transformation.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This enum defines the available output distributions for the QuantileTransformer.
+/// Each distribution has different characteristics and use cases in machine learning.
+/// </para>
+/// <para><b>For Beginners:</b> Think of this as choosing the shape you want your data to take:
+/// - Uniform: Spreads values evenly across the range (like a flat distribution)
+/// - Normal: Creates a bell curve pattern (most values in the middle, fewer at extremes)
+/// </para>
+/// </remarks>
+public enum OutputDistribution
+{
+    /// <summary>
+    /// Maps data to a uniform distribution where all values are equally likely.
+    /// Values are spread evenly across the [0, 1] range.
+    /// </summary>
+    /// <remarks>
+    /// <para><b>For Beginners:</b> This makes your data look like a flat line - every value
+    /// is equally common. Good for algorithms that don't assume any particular distribution.
+    /// </para>
+    /// <para>
+    /// Use this when:
+    /// - You want to reduce the impact of outliers
+    /// - Your algorithm works best with uniformly distributed features
+    /// - You want a simple, predictable transformation
+    /// </para>
+    /// </remarks>
+    Uniform,
+
+    /// <summary>
+    /// Maps data to a normal (Gaussian) distribution with mean 0 and standard deviation 1.
+    /// Values follow a bell curve pattern.
+    /// </summary>
+    /// <remarks>
+    /// <para><b>For Beginners:</b> This makes your data look like a bell curve - most values
+    /// are near the middle, with fewer values at the extremes. Many statistical methods
+    /// assume this distribution.
+    /// </para>
+    /// <para>
+    /// Use this when:
+    /// - Your algorithm assumes normally distributed features (e.g., linear regression, LDA)
+    /// - You want to reduce the impact of outliers while maintaining statistical properties
+    /// - You need compatibility with methods that expect Gaussian distributions
+    /// </para>
+    /// </remarks>
+    Normal
+}
@@ -1,3 +1,5 @@
+using AiDotNet.Enums;
+
 namespace AiDotNet.Models;
 
 /// <summary>
@@ -70,8 +72,10 @@ public NormalizationParameters(INumericOperations<T>? numOps = null)
     {
         _numOps = numOps ?? MathHelper.GetNumericOperations<T>();
         Method = NormalizationMethod.None;
-        Min = Max = Mean = StdDev = Scale = Shift = Median = IQR = P = _numOps.Zero;
+        Min = Max = Mean = StdDev = Scale = Shift = Median = IQR = P = MaxAbs = _numOps.Zero;
         Bins = [];
+        Quantiles = [];
+        OutputDistribution = OutputDistribution.Uniform;
     }
 
     /// <summary>
@@ -372,29 +376,120 @@ public NormalizationParameters(INumericOperations<T>? numOps = null)
     /// <value>The power parameter, used for power transformations.</value>
     /// <remarks>
     /// <para>
-    /// This property stores a power parameter that can be used for certain normalization methods, such as power transformations 
-    /// like Box-Cox or Yeo-Johnson transformations. These transformations can help make skewed data more normally distributed 
-    /// by raising values to a certain power. The optimal power parameter is typically determined during training to maximize 
+    /// This property stores a power parameter that can be used for certain normalization methods, such as power transformations
+    /// like Box-Cox or Yeo-Johnson transformations. These transformations can help make skewed data more normally distributed
+    /// by raising values to a certain power. The optimal power parameter is typically determined during training to maximize
     /// the normality of the transformed data.
     /// </para>
     /// <para><b>For Beginners:</b> This stores a power value used for certain advanced normalization techniques.
-    /// 
+    ///
     /// The power parameter:
     /// - Is used for power transformations like Box-Cox or Yeo-Johnson
     /// - Helps make skewed data more normally distributed
     /// - Can be optimized to find the best transformation
-    /// 
+    ///
     /// For example, a value of 0.5 would correspond to a square root transformation,
     /// which can help normalize right-skewed data.
-    /// 
+    ///
     /// This parameter is useful when:
     /// - Your data has a skewed distribution
     /// - You want to make the data more normally distributed
     /// - Standard normalization methods don't work well
-    /// 
+    ///
     /// Power transformations are more advanced techniques but can significantly
     /// improve model performance with certain types of data.
     /// </para>
     /// </remarks>
     public T P { get; set; }
+
+    /// <summary>
+    /// Gets or sets the maximum absolute value observed in the data.
+    /// </summary>
+    /// <value>The maximum absolute value, used for MaxAbsScaler normalization.</value>
+    /// <remarks>
+    /// <para>
+    /// This property stores the maximum absolute value observed in the data for the feature or target variable.
+    /// It is used for MaxAbsScaler normalization, which scales data to the range [-1, 1] by dividing each value
+    /// by the maximum absolute value. This method preserves the sign of values and maintains zeros (which is
+    /// important for sparse data). The maximum absolute value is typically calculated during training based on
+    /// the training data.
+    /// </para>
+    /// <para><b>For Beginners:</b> This stores the largest absolute value (ignoring the sign) in your data.
+    ///
+    /// The maximum absolute value:
+    /// - Is used for MaxAbsScaler normalization
+    /// - Represents the farthest distance from zero in either direction
+    /// - Is used as a divisor to scale values to the range [-1, 1]
+    ///
+    /// For example, if your data ranges from -75 to 100, the maximum absolute value would be 100,
+    /// and all values would be divided by 100 to scale them to [-0.75, 1.0].
+    ///
+    /// This parameter is important because:
+    /// - It preserves the sign of values (positive stays positive, negative stays negative)
+    /// - It keeps zero values as zero (important for sparse data)
+    /// - It's simpler than min-max scaling but still effective
+    /// </para>
+    /// </remarks>
+    public T MaxAbs { get; set; }
+
+    /// <summary>
+    /// Gets or sets the quantile values used for quantile transformation.
+    /// </summary>
+    /// <value>A list of quantile values representing the empirical distribution.</value>
+    /// <remarks>
+    /// <para>
+    /// This property stores the quantile values calculated from the training data for QuantileTransformer.
+    /// These quantiles represent the empirical cumulative distribution function (CDF) of the data and are
+    /// used to map values to either a uniform or normal distribution. The number of quantiles determines
+    /// the granularity of the transformation.
+    /// </para>
+    /// <para><b>For Beginners:</b> This stores the distribution pattern learned from your training data.
+    ///
+    /// The quantiles list:
+    /// - Is used for QuantileTransformer normalization
+    /// - Contains values that divide your data into equal-sized groups
+    /// - Helps map your data to a target distribution (uniform or normal)
+    ///
+    /// For example, with 100 quantiles:
+    /// - The 25th quantile is the value below which 25% of the data falls
+    /// - The 50th quantile is the median
+    /// - The 75th quantile is the value below which 75% of the data falls
+    ///
+    /// This approach is powerful because:
+    /// - It can handle any input distribution
+    /// - It's very robust to outliers
+    /// - It can transform data to match a desired distribution shape
+    /// </para>
+    /// </remarks>
+    public List<T> Quantiles { get; set; }
+
+    /// <summary>
+    /// Gets or sets the target output distribution for quantile transformation.
+    /// </summary>
+    /// <value>An OutputDistribution enum indicating either Uniform or Normal distribution.</value>
+    /// <remarks>
+    /// <para>
+    /// This property specifies whether the QuantileTransformer should map data to a uniform distribution
+    /// (where all ranges have equal probability) or a normal distribution (bell-shaped curve). This setting
+    /// determines how the quantiles are mapped during transformation.
+    /// </para>
+    /// <para><b>For Beginners:</b> This specifies what shape you want your data to have after transformation.
+    ///
+    /// The output distribution:
+    /// - Can be Uniform (flat distribution) or Normal (bell curve)
+    /// - Affects how values are redistributed
+    /// - Depends on what your machine learning algorithm expects
+    ///
+    /// Uniform distribution:
+    /// - All value ranges have equal numbers of data points
+    /// - Values are spread evenly across the range
+    /// - Good for algorithms that don't assume any particular distribution
+    ///
+    /// Normal distribution:
+    /// - Creates a bell-shaped curve
+    /// - Most values cluster around the center
+    /// - Good for algorithms that work best with normally-distributed data
+    /// </para>
+    /// </remarks>
+    public OutputDistribution OutputDistribution { get; set; }
 }