2

/**
 * Алгоритм генерации первых времен однородного Пуассоновского процесса
 * @param {number} T - единиц времени, время окончания процесса
 */
function poissonProcessUniform(T, lambda = 1) {
	const table_t = {}
	
    let t = 0//начальное время t
    const events = []//массив значений времен событий процесса в возрастающем порядке

    let u = Math.random()//генерация случайного числа
    t = t - 1 / lambda * Math.log(u)//Присваиваем t по формуле из алгоритма генерации первых т врмен однор процесса
	
    while (!(t > T)) {//сравниваем
	console.log(`Время наступления события: `)
		console.log(t)
        events.push(t)//если меньше, то добавляем в массив значений времен
						//иначе возвращаемся к шагу генерация случайного числа
        u = Math.random()
        t = t - 1 / lambda * Math.log(u)//xi
		
    }

    return { events, count: events.length }//считаем колво событий, которые произойдут к моменту времени time
}
/*неоднородный пуассоновский процесс*/
function poissonProcessNonuniform(T, lambda = 1, functionIntensity) {
    let t = 0	//Инициализируем значение начального времени t
    const events = []	//	Инициализируем массив значений времен событий процесса

    let u = Math.random()	//	Генерируем равномерную случайную переменную u на отрезке [0,1]:
    t = t - 1 / lambda * Math.log(u)	// Задаем значение начального времени t по формуле

    while (!(t > T)) {
        const u2 = Math.random()	//	Генерируем равномерную случайную переменную u2 на отрезке [0,1]
        if (u2 <= (functionIntensity(t) / lambda)) {
			console.log(`Время наступления события: `)
		console.log(t)
            events.push(t)
        }

        u = Math.random()
        t = t - 1 / lambda * Math.log(u)
    }

    return { events, count: events.length }  
}


function functionIntensity(t) {//ф инт
    return 1 + 2/(t+1)
}

function factorial(n) {
    if (n < 2) {
        return 1
    }

    let result = 1
    for (let i = 1; i <= n; i++) {
        result *= i
    }
    return result
}

function checkPoisson(values, N) {//проверка пуас
    const chi2Criticals = [
        3.8,
        6,
        7.8,
        9.5,
        11.1,
        12.6,
        14.1,
        15.5,
        16.9,
        18.3,
    
        19.7,
        21,
        22.4,
        23.7,
        25,
        26.3,
        27.6,
        28.9,
        30.1,
        31.4
    ]

    // разбитие, число значений, число групп выборки s
    const s = values.length

    // выборочное среднее
	//для оценки параметра лямбда теор
    const mean = 1 / N * values.reduce((acc, value, i) => acc + (value * i), 0)
	
	//лямбда теоретическое
    const expectedLambda = mean

	//теоретические частоты числа событий в интервале времени
    const theoryValues = []
    values.forEach((_, i) => {
        const fact = factorial(i)
        const pi = Math.exp(-expectedLambda) * (expectedLambda**i) / fact
        theoryValues[i] = pi * N
		//pi - вероятность 
		console.log('Вероятность Р' + i + ': ')
		console.log(pi);
    })
    
    // критерий согласия Пирсона (хи квадрат наблюдаемое)
	//частота числа событий  теор частота 
    const chi2 = values.reduce((acc, _, i) => acc + ((values[i] - theoryValues[i])**2 / theoryValues[i]), 0)

    // задаем степень свободы
    const k = s - 2

    // хи квадрат критическое при заданном k
    const chi2Critical = chi2Criticals[k-1]

    const result = {}
    values.forEach((value, i) => {
        result[i] = {
            "число событий": i,
            "частота": value,
            "частота теоретическая": theoryValues[i]
        }
    })
    console.table(result)

    console.log(`Степень свободы k = ${k}`)
    console.log(`Уровень значимости alpha = 0.05`)

    console.log(`Хи квадрат наблюдаемое = ${chi2}`)
    console.log(`Хи квадрат критическое = ${chi2Critical}`)
	
	
	//проверка гипотезы о принадлжености числа событий на интервале времени длины time 
	//заданного пуассоновского процесса пуассоновскому распределению(<)
    console.log(`Хи2 наблюдаемое ${chi2 < chi2Critical ? '<' : '>='} Хи2 критическое => исследуемая случайная переменная ${chi2 < chi2Critical ? '' : 'не '}принадлежит закону распределения`)
}


function main() {
    const lambda = 1
    const time = 1//время окончания процесса
    const N = 10//число испытаний

    console.log(`время = ${time}, lambda = ${lambda}, испытаний = ${N}:`)
    
    console.log(`Однородный Пуассоновский процесс:`);
	
	//Инициализируем массив values частот числа событий в интервале времени
    let values = []
	
	
	//Считаем частоты числа событий на интервале времени длины time
    for (let index = 0; index < N; index++) {
        const x = poissonProcessUniform(time, lambda).count//выводим количесвто событий
        if (values[x]) {
            values[x] += 1
        } else {
            values[x] = 1
        }  
    }

    checkPoisson(values, N)

    console.log()

    console.log(`Неоднородный Пуассоновский процесс:`);
    values = []
    for (let index = 0; index < N; index++) {
        const x = poissonProcessNonuniform(time, lambda, functionIntensity).count
        if (values[x]) {
            values[x] += 1
        } else {
            values[x] = 1
        }  
    }

    checkPoisson(values, N)
}
main()