import java.util.function.Function;
/**
 * @ClassName : RectangleMembershipFunction  //类名
 * @Description : 矩形模糊隶属函数  //描述
 * @Author : 主教 //作者
 * @Date: 2023/4/14  9:12
 */
public class RectangleMembershipFunction {
    private double a;
    private double b;
    public RectangleMembershipFunction(double a, double b) {
        this.a = a;
        this.b = b;
    }
    public double compute(double x) {
        if (x >= a && x <= b) {
            return 1;
        } else {
            return 0;
        }
    }
    public Function<Double, Double> createRectangleMembershipFunction(){
        return this::compute;
    }
}

import java.util.function.Function;
/**
 * @ClassName : TrapezoidMembershipFunction  //类名
 * @Description : 梯型模糊隶属函数  //描述
 * @Author : 主教 //作者
 * @Date: 2023/4/14  9:09
 */
public class TrapezoidMembershipFunction {
    private double a;
    private double b;
    private double c;
    private double d;
    public TrapezoidMembershipFunction(double a, double b, double c, double d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }
    public double compute(double x) {
        if (x < a || x > d) {
            return 0;
        } else if (x >= b && x <= c) {
            return 1;
        } else if (x < b) {
            return (x - a) / (b - a);
        } else {
            return (d - x) / (d - c);
        }
    }
    public Function<Double, Double> createTrapezoidMembershipFunction(){
        return this::compute;
    }
}

import java.util.function.Function;
/**
 * @ClassName : ParabolicMembershipFunction  //类名
 * @Description : k次抛物型模糊隶属函数  //描述
 * @Author : 主教 //作者
 * @Date: 2023/4/14  9:17
 */
public class ParabolicMembershipFunction {
    private double a;
    private double b;
    private double c;
    private double d;
    private int k;
    public ParabolicMembershipFunction(double a, double b, double c, double d, int k) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.k = k;
    }
    public double compute(double x) {
        if (x <= a || x >= d) {
            return 0;
        } else if (x > a && x <= b) {
            return Math.pow((x - a) / (b - a), k);
        } else if (x > b && x <= c) {
            return 1;
        } else {
            return Math.pow((d - x) / (d - c), k);
        }
    }
    public Function<Double, Double> createParabolicMembershipFunction(){
        return this::compute;
    }
}

import java.util.function.Function;
/**
 * @ClassName : TMembershipFunction  //类名
 * @Description : T型模糊隶属函数  //描述
 * @Author : 86138 //作者
 * @Date: 2023/4/14  9:25
 */
public class TMembershipFunction {
    private double a;
    private double m;
    private double n;
    public TMembershipFunction(double a, double m, double n) {
        this.a = a;
        this.m = m;
        this.n = n;
    }
    public double compute(double x) {
        if (x <= a) {
            return 0;
        } else if (x > a && x <= m) {
            return (x - a) / (m - a);
        } else if (x >= m && x < n) {
            return 1;
        } else {
            return (n - x) / (n - m);
        }
    }
    public Function<Double, Double> createTMembershipFunction(){
        return this::compute;
    }
}

import java.util.function.Function;
/**
 * @ClassName : GaussianMembershipFunction  //类名
 * @Description : 正态型模糊隶属函数  //描述
 * @Author : 86138 //作者
 * @Date: 2023/4/14  9:27
 */
public class GaussianMembershipFunction {
    private double mu;
    private double sigma;
    public GaussianMembershipFunction(double mu, double sigma) {
        this.mu = mu;
        this.sigma = sigma;
    }
    public double compute(double x) {
        return (1 / (sigma * Math.sqrt(2 * Math.PI))) * Math.exp(-((x - mu) * (x - mu)) / (2 * sigma * sigma));
    }
    public Function<Double, Double> createGaussianMembershipFunction(){
        return this::compute;
    }
}

import java.util.function.Function;
/**
 * @ClassName : CauchyMembershipFunction  //类名
 * @Description : 柯西型模糊隶属函数  //描述
 * @Author : 86138 //作者
 * @Date: 2023/4/14  9:29
 */
public class CauchyMembershipFunction {
    private double x0;
    private double gamma;
    public CauchyMembershipFunction(double x0, double gamma) {
        this.x0 = x0;
        this.gamma = gamma;
    }
    public double compute(double x) {
        return (1 / Math.PI) * (gamma / ((x - x0) * (x - x0) + gamma * gamma));
    }
    public Function<Double, Double> createCauchyMembershipFunction(){
        return this::compute;
    }
}