void setup(void) {
add_area("2.4.5");
set_short("Village church");
set_long("You are in the local village church. There is a huge " +
"pit in the center, and a door in the west wall. " +
"There is a button beside the door. This church has the service " +
"of reviving ghosts. Dead people come to the church and pray. " +
"there is a clock on the wall. There is an exit to the south.");
add_exit("south", DIR + "/rooms/vill_green.c");
add_item("clock","The clock appears to be broken, it is stuck at: 1:26");
add_item("pit","In the middle of the church is a deep pit. IT was used " +
"for sacrifice in the old times, but nowadays it is only " +
"left for tourists to look at.");
el = get_el();
if (el) {
if (el->query_location() == 3) {
el_arrives();
} else {
el_leaves();
}
}
}
// Находим значение fris-функции, для верифицированной выборки, где определён единственный столп:
// num_cl - номер класса, для которого определен единственный столп;
// smpl - единственный столп класса num_cl;
// dm - матрица подобия;
// cl - вектор разбиения;
// kol_st - количество верифицированных образов;
// n - количество классов в разбиении;
// rez - переменная для формирования результата;
void fris_compact_verified(int * num_cl, int * smpl, double * dm, int * cl, int * kol_st, int * n, double * rrr, double *rez) {
double rho_self, rho_alien, rho, rho_min, rho_cl[*n];
double f=0, r=0;
int k, i, j, num_class, el;
for (k = 1; k <= *kol_st; k++){ // для каждого образца находим расстояние до ближайшего своего и ближайшего чужого.
rho_self=0;
rho_alien=*rrr;
if (k != *smpl){ // рассматриваем его, если только он не является передаваемым столпом
if(cl[k-1] == *num_cl){ // находим расстояния, если он попадает в передаваемый класс
rho_self = get_el(dm, k, *smpl, kol_st);
for ( i = 1; i <= *kol_st; i++){
if (cl[i-1] != cl[k-1]){
rho = get_el(dm, k, i, kol_st);
if (rho_alien > rho){
rho_alien = rho;
}
}
}
}else{ // находим расстояния, если он не попадает в передаваемый класс
rho = get_el(dm, k, *smpl, kol_st);
if (rho_alien > rho){
rho_alien = rho;
}
for (i = 1; i <= *kol_st; i++){
if(cl[i-1] == cl[k-1]){
if (rho_self==0){
rho_self=get_el(dm, k, i, kol_st);
}else{
rho = get_el(dm, k, i, kol_st);
if (rho_self>rho){
rho_self = rho;
}
}
}
}
}
}
f = fris(rho_self, rho_alien); // считаем значение fris-функции для k образца
r=r+f;
}
*rez = r / *kol_st; // Находим значение fris- функции, сумму значений fris-функций делим на количество образцов в смешанной выборке
}
double get_min(int * ss, int * kol, int k, double * dm_mix, int * kol_ss){
int i;
double mn, rho;
mn = 0;
for (i=1; i<= *kol; i++){
if (ss[i] != 0 && ss[i]!=k){
if (mn == 0){
mn = get_el(dm_mix, k, ss[i], kol_ss);
}else{
rho = get_el(dm_mix, k, ss[i], kol_ss);
if (mn > rho){
mn = rho;
}
}
}
}
i = 0;
rho = 0;
return mn;
}
void reduced_fris(int * k, int * s, int * kol, double * dm, double * rho_alien, double * rez){
int i, j;
double rho_self, rho, f, re;
for (i = 1; i <= *kol; i++){
rho_self = 0;
for (j = 1; j<= *k; j++){
if(rho_self == 0){
rho_self = get_el(dm, s[j-1], i, kol);
}else{
rho= get_el(dm, s[j-1], i, kol);
if (rho_self > rho){
rho_self = rho;
}
}
}
f = fris(rho_self, *rho_alien); // считаем значение fris-функции для k образца
re=re+f;
}
*rez = re / *kol;
}
void est(int * kol_class, int * s, int * kol, double * dm, double * rrr, double * rez, int * cl){
int i, j, k, num, ss[*kol_class];
double rho_self, rho, f, re, max;
const l = 1;
for (i = 1; i <= *kol; i++) {
rho_self = get_el(dm, s[0], i, kol);
num = 1;
for (j = 1; j<= *kol_class; j++){
rho= get_el(dm, s[j-1], i, kol);
if (rho_self > rho){
rho_self = rho;
num = j;
}
}
cl[i-1] = num;
}
for (k = 1; k<=*kol_class; k++){
fris_compact_verified(&k, &l, dm, cl, kol, kol_class, rrr, rez);
max = *rez;
num = i;
for (i = 1; i <= *kol; i++){
if (cl[i-1] == k){
fris_compact_verified(&k, &i, dm, cl, kol, kol_class, rrr, rez);
if (max < *rez){
max = *rez;
num = i;
}
}
}
ss[k-1] = num;
s[k-1] = num;
}
fris_compact_ss_verified(&ss, kol, dm, cl, kol_class, &l, rrr, rez);
}
// Находим значение fris-функции, для смешанной выборки, где определён единственный столп:
// num_cl - номер класса, для которого определен единственный столп;
// smpl - единственный столп класса num_cl;
// kol_ss - количество образцов в смешанной выборке;
// dm_mix - матрица подобия;
// cl - вектор разбиения;
// kol_st - количество верифицированных образов;
// n - количество классов в разбиении;
// rez - переменная для формирования результата;
void fris_compact(int * num_cl, int * smpl, int * kol_ss, double * dm_mix, int * cl, int * kol_st, int * n, double *rez) {
double rho_self, rho_alien, rho, rho_min, rho_cl[*n];
double f=0, r=0;
int k, i, j, num_class, el;
for (k = 1; k <= *kol_ss; k++){ // для каждого образца находим расстояние до ближайшего своего и ближайшего чужого.
rho_self=0;
rho_alien=3;
if (k != *smpl-1){ // рассматриваем его, если только он не является передаваемым столпом
if (k <= *kol_st){
if(cl[k-1] == *num_cl){ // находим расстояния, если он попадает в передаваемый класс
rho_self = get_el(dm_mix, k, *smpl, kol_ss);
for ( i = 1; i <= *kol_st; i++){
if (cl[i-1] != cl[k-1]){
rho = get_el(dm_mix, k, i, kol_ss);
if (rho_alien > rho){
rho_alien = rho;
}
}
}
}else{ // находим расстояния, если он не попадает в передаваемый класс, но является верифицированным.
rho = get_el(dm_mix, k, *smpl, kol_ss);
if (rho_alien > rho){
rho_alien = rho;
}
for (i = 1; i <= *kol_ss; i++){
if(cl[i-1] == cl[k-1] || i > *kol_st){
if (rho_self==0){
rho_self=get_el(dm_mix, k, i, kol_ss);
}else{
rho = get_el(dm_mix, k, i, kol_ss);
if (rho_self>rho){
rho_self = rho;
}
}
}
}
}
}else{ // находим расстояния, если образец является неверифицированным.
rho_min = 0; // находим ближайший верифицированный элемент
el = 0;
for (j = 1; j <= *kol_st; j++){
if (rho_min == 0){
rho_min = get_el(dm_mix, k, j, kol_ss);
el = j;
}else{
rho = get_el(dm_mix, k, j, kol_ss);
if (rho_min > rho ){
rho_min = rho;
el = j;
}
}
}
num_class = cl [el - 1]; // определяем класс, которому принадлежит ближайший элемент.
if (num_class == *num_cl){ // считаем расстояния, если класс образца совпадает с передоваемым
rho_self = get_el(dm_mix, k, *smpl, kol_ss);
for ( i = 1; i <= *kol_st; i++){
if (cl[i-1] != num_class){
rho = get_el(dm_mix, k, i, kol_ss);
if (rho_alien > rho){
rho_alien = rho;
}
}
}
}else{
rho = get_el(dm_mix, k, *smpl, kol_ss);
if (rho_alien > rho) {
rho_alien = rho;
}
for (i = 1; i <= *kol_ss; i++){
if(cl[i-1] == num_class || i > *kol_st){
if (rho_self==0){
rho_self=get_el(dm_mix, k, i, kol_ss);
}else{
rho = get_el(dm_mix, k, i, kol_ss);
if (rho_self > rho){
rho_self = rho;
}
}
}
}
}
}
}
f = fris(rho_self, rho_alien); // считаем значение fris-функции для k образца
r=r+f;
}
*rez = r / *kol_ss; // Находим значение fris- функции, сумму значений fris-функций делим на количество образцов в смешанной выборке
}
void fris_class(double * dm, int *kol, int * kol_class, int * stolps, int * cl, double * ff, double * alpha ){
int i, j, jj, k, l, area, points[*kol], count = 0, merger[* kol_class][* kol_class], a=-1, b=-1;
double rho, rho_k, rho_l, f, rho_a, rho_b;
for (k = 1; k<= *kol_class; k++){
for (l = 1; l<= *kol_class; l++){
if (k==l){
merger[k][l] = 1;
}else{
merger[k][l] = 0 ;
}
}
}
for (k = 1; k < *kol_class; k++){
for (l = k; l <= *kol_class; l++){
if (l != k){
for (i = 1; i <= *kol; i++){
if (cl[i-1] == k || cl[i-1] == l){
rho_k = get_el(dm, stolps[k-1], i, kol);
rho_l = get_el(dm, stolps[l-1], i, kol);
area = 1;
for (j=0; j<*kol_class; j++){
if (rho_k > get_el(dm, stolps[j], i, kol) || rho_l > get_el(dm, stolps[j], i, kol)){
area=0;
}else{
area = 1;
}
}
if (area==1 & cl[i-1] == k){
f = fris(rho_k, rho_l);
}
if (area==1 & cl[i-1] == l){
f = fris(rho_l, rho_k);
}
if (f > *ff){
area=0;
}
if (area == 1){
points[count] = i; // точка попавшая в зону конкуренции
count ++;
}
}
}
}
}
}
count--;
for (i=0; i<=count; i++){ // идем по всем точкам, попавшим в зону конкуренции, проверяем надо ли объединять по ним классы.
k = cl[points[i]-1]; // k - класс первой точки
rho_l = 0;
for (j = 0; j<*kol_class; j++){
if (rho_l == 0 && cl[stolps[j]-1] != k ){
rho_l = get_el(dm, stolps[j], points[i], kol);
l = cl[stolps[j]-1];
}
if(cl[stolps[j]-1] != k && rho_l > get_el(dm, stolps[j], points[i], kol)){
l = cl[stolps[j]-1]; // l - класс второй точки
}
}
if (merger[k][l] != 1 && merger[l][k] != 1){ //проверяем надо ли объединять k и l классы
rho_a = 0; //расстояние до ближайшего своего от точки а;
rho_b = 0; //расстояние до ближайшего своего от точки b;
rho = 0; //минимальное расстояние между a и b точками из классов l и k;
for (j = 0; j <= count; j++){
for (jj = j+1; jj <= count; jj++){
if(cl[points[j]-1] != cl[points[jj]-1]){
if (rho == 0) {
rho = get_el(dm, points[j], points[jj], kol);
a=points[j];
b=points[jj];
}else{
if (rho > get_el(dm, points[j], points[jj], kol)){
rho = get_el(dm, points[j], points[jj], kol);
a=points[j];
b=points[jj];
}
}
}
}
}
if (a < 0 || b < 0) {
merger[k][l] = 0;
merger[l][k] = 0;
}else{
for (j = 1; j <= *kol; j++){
if (j != a && j != b){
if (cl[j-1] == cl[a-1]){
if (rho_a == 0){
rho_a = get_el(dm, j, a, kol);
}else{
if(rho_a > get_el(dm, j, a, kol)){
rho_a = get_el(dm, j, a, kol);
}
}
}
if (cl[j-1] == cl[b-1]){
if (rho_b == 0){
rho_b = get_el(dm, j, b, kol);
}else{
if(rho_b > get_el(dm, j, b, kol)){
rho_b = get_el(dm, j, b, kol);
}
}
}
}
}
if (rho_a < (*alpha * rho_b) && rho_b < (*alpha * rho_a) && rho < *alpha *((rho_a+rho_b)/2)){
merger[k][l] = 1;
merger[l][k] = 1;
}
}
}
}
for (k = *kol_class; k>=1; k--){
for (i=1; i<=*kol; i++){
if(cl[i-1] != k && merger[cl[i-1]][k]==1){
cl[i-1] = k;
}
}
}
/*int bb[*kol];
count=0;
for (i = 0; i<*kol; i++){
if (cheking(cl[i], bb, *kol)=="TRUE"){
bb[count]= cl[i];
count ++;
}
}
for (k=1; k<=count;k++){
for (i = 0; i<*kol; i++){
if(bb[k-1]==cl[i]){
cl[i]=k;
}
}
}*/
}
