Форум DL

Мой профиль

Задача №30

// Объявление входных и выходных переменных
int __in __bits(16) A;
int __in __bits(16) B;
int __in __bits(16) C;
int __in __bits(16) D;
int __out __bits(16) RES;

// Определение типов с помощью макросов
#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

// Библиотека функций C-MPA
i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

i16 CONST    (i16 A) {return A;}
u16 CBW      (u8  A) {return A;}
u32 CWD      (u16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}

// Главная функция для вычисления RES
void main() {
    // Преобразование входных переменных к 32-битному формату
    i32 a32 = CWD(A);
    i32 b32 = CWD(B);
    i32 c32 = CWD(C);
    i32 d32 = CWD(D);

    // Выражение для res1
    i32 temp1 = IMUL(C, D); // IMUL: параметры i16 -> результат i32
    i16 temp2 = x32Tox16(a32); // Преобразование a32 в i16
    i16 temp3 = x32Tox16(b32); // Преобразование b32 в i16
    i16 temp4 = SUM(temp2, temp3); // A + B
    i16 temp5 = CONST(1); // Константа 1
    i16 temp6 = SUM(temp4, temp5); // (A + B) + 1
    i32 temp7 = CWD(temp6); // Преобразование суммы в i32
    i16 temp8 = IDIV(temp1, temp7); // (C * D) / ((A + B) + 1)
    i16 res1 = SUM(A, temp8); // A + ((C * D) / ((A + B) + 1))

    // Выражение для res2
    i32 temp9 = IMUL(B, C); // B * C -> i32
    i32 temp10 = IMUL(D, A); // D * A -> i32
    i16 temp11 = x32Tox16(temp9); // Преобразование в i16
    i16 temp12 = x32Tox16(temp10); // Преобразование в i16
    i16 temp13 = ISUB(temp11, temp12); // B * C - D * A
    i16 temp14 = SUM(A, C); // A + C
    i32 temp15 = IMUL(temp13, temp14); // (B * C - D * A) * (A + C)
    i16 temp15_1 = x32Tox16(temp15); // i32 -> i16
    i16 temp16 = IDIV(a32, b32); // A / B
    i16 res2 = ISUB(temp16, temp15_1); // A / B - ((B * C - D * A) * (A + C))

    // Выражение для res3
    i16 two = CONST(2); // Константа 2
    i32 temp17 = IMUL(two, C); // 2 * C -> i32
    i16 temp18 = IDIV(temp17, d32); // 2 * C / D -> i16
    i16 temp19 = ISUB(A, temp18); // A - (2 * C / D)
    i16 temp20 = ISUB(temp19, B); // A - (2 * C / D) - B
    i16 temp21 = IDIV(b32, d32); // B / D -> i16
    i32 temp22 = IMUL(C, B); // C * B -> i32
	i16 temp23 = x32Tox16(temp22); // C * B -> i16
    i16 temp24 = ISUB(temp23, A); // C * B - A
    i16 temp25 = ISUB(temp24, temp21); // (C * B - A) - (B / D)
    i32 temp26 = IMUL(temp20, temp25); // (A - (2 * C / D) - B) * ((C * B - A) - (B / D))
	i16 res3   = x32Tox16(temp26); // res i32 -> i16

    // Сравнение A и B для выбора выражения
    ICMPResult(a32, b32);
    u1 cond1 = IEQ; // A == B
    u1 cond2 = ILT; // A < B

    // Выбор результата на основе условия
    i16 temp27 = MSb16x2(res2, res1, cond1);
    RES = MSb16x2(temp27, res3, cond2);
}

Мой профиль

Задача №17

#include <hlccad.mpc>

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) b;
int __out __bits(16) R;

void main() {
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i32 a32 = CWD(a16);
    i16 b16 = CBW(b);
    i32 b32 = CWD(b16);

    // Ветка 1:  x >= 0: (x * a) + (y / b) - a
    i32 x_a_mul = IMUL(x, a16);
    i16 x_a_16 = x32Tox16(x_a_mul);
    i16 y_div_b = IDIV(y32, b32);
    i16 res1_temp = SUM(x_a_16, y_div_b);
    i16 res1 = ISUB(res1_temp, a16);

    // Ветка 2:  x < 0: (y * b) + ((x - 2) / a)
    i32 y_b_mul = IMUL(y, b16);
    i16 y_b_16 = x32Tox16(y_b_mul);
    i16 two = CONST(2);
    i16 x_minus_2 = ISUB(x, two);
    i32 x_m2_32 = CWD(x_minus_2);
    i16 x_m2_div_a = IDIV(x_m2_32, a32);
    i16 res2 = SUM(y_b_16, x_m2_div_a);

    // Составление условия
    i16 zero16 = CONST(0);
	i32 zero32 = CWD(zero16);
    ICMPResult(x32, zero32);
    u1 cond = OR2(IGT, IEQ);  // x >= 0

    R = MSb16x2(res2, res1, cond);
}

Мой профиль

В течении пары пытался добиться от нейросетей генерации визуальной схемы для отображения алгоритма , который бы дал пользователю возможность изучить его, и применить при работе с HLCCAD.К сожалению , добиться желаемого через генерацию изображений не представляю возможным, однако, вижу потенциал в отрисовке изображения благодаря текстовым символам и считаю, что необходимо пробовать дальше добиться желаемого от языковых моделей.Результат отрисовки схемы будет в txt файле на google диск: https://drive.google.com/file/d/1b9nX9DKaq-lHTn7NYTsUJMASGS0SQI4N/view?usp=sharing.

Мой профиль

Результат отрисовки схемы от chatgpt.com:

https://drive.google.com/file/d/1LvkB1kaMKIYw52hLkJN8e31BuqFxPkMn/view?usp=sharing

Мой профиль

Задача №29

#include <hlccad.mpc>

int __in __bits(16) A;
int __in __bits(16) B;
int __in __bits(16) C;
int __in __bits(16) D;
int __out __bits(16) RES;

void main() {
    i32 a32 = CWD(A);
    i32 b32 = CWD(B);
    i32 c32 = CWD(C);
    i32 d32 = CWD(D);

    i32 AB_mul_32 = IMUL(A, B); // A * B
    i16 AB_mul_16 = x32Tox16(AB_mul_32);

    // Ветка 1 (B*A > 0): A/B+C*(B-D/A)
    i16 D_div_A_16 = IDIV(d32, a32);
    i16 BD_sub_DA_16 = ISUB(B, D_div_A_16);
    i32 C_BD_sub_DA_32 = IMUL(C, BD_sub_DA_16);
    i16 C_BD_sub_DA_16 = x32Tox16(C_BD_sub_DA_32);
    i16 A_div_B_16 = IDIV(a32, b32);
    i16 res1 = SUM(A_div_B_16, C_BD_sub_DA_16);

    // Ветка 2 (B*A <= 0): C-B/D-C*(B-D)
    i16 B_div_D_16 = IDIV(b32, d32);
    i16 C_sub_BD_16 = ISUB(C, B_div_D_16);
    i16 BD_sub_D_16 = ISUB(B, D);
    i32 C_BD_sub_D_32 = IMUL(C, BD_sub_D_16);
    i16 C_BD_sub_D_16 = x32Tox16(C_BD_sub_D_32);
    i16 res2 = ISUB(C_sub_BD_16, C_BD_sub_D_16);

    // Составление условия и вывод результата
    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);
    ICMPResult(AB_mul_16, zero32);
    u1 isPositive = IGT;
    RES = MSb16x2(res2, res1, isPositive);
}

Мой профиль

Задача №26

#include <hlccad.mpc>

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) c;
int __out __bits(16) RES;

void main() {
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i16 c16 = CBW(c);
    i32 a32 = CWD(a16);
    i32 c32 = CWD(c16);

    // Ветка 1: x * y + a * c - x / c (x * y < 0)
    i32 xy_mul_32 = IMUL(x, y);               // x * y
	i16 xy_mul_16 = x32Tox16(xy_mul_32);
    i32 ac_mul_32 = IMUL(a16, c16);           // a * c
    i16 ac_mul_16 = x32Tox16(ac_mul_32);
    i16 term1 = SUM(xy_mul_16, ac_mul_16);    // x * y + a * c
    i16 x_div_c = IDIV(x32, c32);             // x / c
    i16 res1 = ISUB(term1, x_div_c);          // res1 = x * y + a * c - x / c

    // Ветка 2: x * c - y * a + y / a (x * y >= 0)
    i32 xc_mul_32 = IMUL(x, c16);             // x * c
    i16 xc_mul_16 = x32Tox16(xc_mul_32);
    i32 ya_mul_32 = IMUL(y, a16);             // y * a
    i16 ya_mul_16 = x32Tox16(ya_mul_32);
    i16 term2 = ISUB(xc_mul_16, ya_mul_16);   // x * c - y * a
    i16 y_div_a = IDIV(y32, a32);             // y / a
    i16 res2 = SUM(term2, y_div_a);           // res2 = x * c - y * a + y / a

    // Составление условия и вывод результата
    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);
    ICMPResult(xy_mul_32, zero32);
    u1 isNegative = ILT;
    RES = MSb16x2(res2, res1, isNegative);
}

Мой профиль

Задача №23

#include <hlccad.mpc>

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) c;
int __out __bits(16) RES;

void main() {
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i32 a32 = CWD(a16);
    i16 c16 = CBW(c);
    i32 c32 = CWD(c16);

    // Ветка 1: ((x - y)^2) / (a + c) (x * y < 0)
    i16 xy_diff = ISUB(x, y);           // x - y
    i32 xy_diff_squared = IMUL(xy_diff, xy_diff); // (x - y)^2
    i16 ac_sum = SUM(a16, c16);         // a + c
    i32 ac_sum_32 = CWD(ac_sum);
    i16 res1 = IDIV(xy_diff_squared, ac_sum_32); // res1 = ((x - y)^2) / (a + c)

    // Ветка 2: (a - c) / (x^2 + y^2) (x * y >= 0)
    i16 ac_diff = ISUB(a16, c16);       // a - c
    i32 x_squared = IMUL(x, x);         // x^2
    i32 y_squared = IMUL(y, y);         // y^2
    i32 xy_sum = SUM(x_squared, y_squared); // x^2 + y^2
    i32 ac_diff_32 = CWD(ac_diff);
    i16 res2 = IDIV(ac_diff_32, xy_sum);   // res2 = (a - c) / (x^2 + y^2)

    // Составление условие и вывод результата
    i32 xy_mul = IMUL(x, y);
    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);
    ICMPResult(xy_mul, zero32);
    u1 isNegative = ILT;
    RES = MSb16x2(res2, res1, isNegative);
}

Мой профиль

Задача №27

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) c;
int __out __bits(16) RES;


#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)


i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u16 CBW      (u8  A) { return A; }
u32 CWD      (u16 A) { return A; }
i16 CONST    (i16 A) { return A; }

i16 x32Tox16 (i32 A) { return A; }
i8  x16Tox8  (i16 A) { return A; }

i16 SUM      (i16 A, i16 B) { i16 C; C = A + B; return C; }
i16 ISUB     (i16 A, i16 B) { i16 C; C = A - B; return C; }
i32 IMUL     (i16 A, i16 B) { i32 C; C = A * B; return C; }
i16 IDIV     (i32 A, i32 B) { i16 C; C = A / B; return C; }

u16 MSb16x2  (u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3  ICMP     (i32 A, i32 B) { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1  IGT;
u1  IEQ;
u1  ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

void main() {

    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i16 c16 = CBW(c);


    i32 x2_32 = IMUL(x, x);                 // x^2
    i16 x2_16 = x32Tox16(x2_32);
    i32 y2_32 = IMUL(y, y);                 // y^2
    i16 y2_16 = x32Tox16(y2_32);
    i16 x2_y2_sum = SUM(x2_16, y2_16);      // x^2 + y^2
    i32 a2_32 = IMUL(a16, a16);             // a^2
    i16 x2_y2_div_a2 = IDIV(x2_y2_sum, a2_32); // (x^2 + y^2) / a^2
    i32 c2_32 = IMUL(c16, c16);             // c^2
    i16 c2_16 = x32Tox16(c2_32);
    i32 c3_32 = IMUL(c2_16, c16);           // c^3
    i16 x2_y2_div_a2_minus_c3 = ISUB(x2_y2_div_a2, c3_32); // (x^2 + y^2) / a^2 - c^3
    i16 x_y_sum = SUM(x, y);                // x + y
    i32 res1_32 = IMUL(x2_y2_div_a2_minus_c3, x_y_sum); // res1 = ((x^2 + y^2) / a^2 - c^3) * (x + y)
    i16 res1 = x32Tox16(res1_32);


    i32 x2_32_second = IMUL(x2_16, x2_16);  // x^4
    i16 x4_16 = x32Tox16(x2_32_second);
    i16 y2_div_a2 = IDIV(y2_32, a2_32);     // y^2 / a^2
    i16 x4_minus_y2_div_a2 = ISUB(x4_16, y2_div_a2); // x^4 - y^2 / a^2
    i32 c4_32 = IMUL(c2_16, c2_16);         // c^4
    i16 c4_16 = x32Tox16(c4_32);
    i32 x_c4 = IMUL(x, c4_16);              // x * c^4
    i16 x_c4_16 = x32Tox16(x_c4);
    i16 res2 = SUM(x4_minus_y2_div_a2, x_c4_16); // res2 = x^4 - y^2 / a^2 + x * c^4


    i32 x_y_mul = IMUL(x, y);               // x * y
    i16 zero = CONST(0);
    i32 zero32 = CWD(zero);
    ICMPResult(x_y_mul, zero32);
    u1 cond = ILT;  // x * y < 0


    RES = MSb16x2(res2, res1, cond);
}

Мой профиль

Задача №20

#include <hlccad.mpc>

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) b;
int __out __bits(16) r;

void main() {
    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);
    i16 five = CONST(5);
    i32 five32 = CWD(five);
    i16 a16 = CBW(a);
    i16 b16 = CBW(b);
    i32 a32 = CWD(a16);
    i32 b32 = CWD(b16);
    i32	x32 = CWD(x);

    // Ветка 1: 5 * x + a / b - y (a>=0 и b не равно 0)
    i32 five_x = IMUL(five, x);
    i16 five_x_16 = x32Tox16(five_x);
    i16 a_div_b = IDIV(a32, b32);
    i16 first_expr = SUM(five_x_16, a_div_b);
    i16 first_expr_final = ISUB(first_expr, y);

    // Ветка 2: x / 5 - b / a + y (в остальных случаях)

    i16 x_div_5 = IDIV(x32, five32);
    i16 b_div_a = IDIV(b32, a32);
    i16 second_expr = ISUB(x_div_5, b_div_a);
    i16 second_expr_final = SUM(second_expr, y);

    // Составление условия и вывод результата
    ICMPResult(a32, zero32);
    u1 cond1 = ILT; // a < 0
    ICMPResult(b32, zero32);
    u1 cond2 = IEQ; // b == 0
    u1 final_cond = OR2(cond1, cond2);
    r = MSb16x2(first_expr_final, second_expr_final, final_cond);
}

Мой профиль

Исправленный файл препромта для ИИ: https://docs.google.com/document/d/e/2PACX-1vTwEEjhNCBZl69X18fg_QIGYbR1WyFBPWboN75lHDDO65j3r7NxaMCOKPwMRHxX9sgBZEU5ZFIwt3pG/pub

На текущий момент необходима нейросеть, которая позволит запомнить всю информацию. Я разделил файл на условные 4 части, чтобы облегчить запоминание отправляя небольшими кусками на случай если ИИ не может запомнить всё сразу.

Мой профиль

Задача №24

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) c;
int __out __bits(16) RES;


#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u16 CBW      (u8  A) { return A; }
u32 CWD      (u16 A) { return A; }
i16 CONST    (i16 A) { return A; }

i16 x32Tox16 (i32 A) { return A; }
i8  x16Tox8  (i16 A) { return A; }

i16 SUM      (i16 A, i16 B) { i16 C; C = A + B; return C; }
i16 ISUB     (i16 A, i16 B) { i16 C; C = A - B; return C; }
i32 IMUL     (i16 A, i16 B) { i32 C; C = A * B; return C; }
i16 IDIV     (i32 A, i32 B) { i16 C; C = A / B; return C; }

u16 MSb16x2  (u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3  ICMP     (i32 A, i32 B) { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1  IGT;
u1  IEQ;
u1  ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

void main() {
    // Приведение x и y к 32-битным значениям
    i32 x32 = CWD(x);    // x -> 32 бита
    i32 y32 = CWD(y);    // y -> 32 бита

    // Приведение a и c к 16-битным значениям, затем к 32 битам
    i16 a16 = CBW(a);    // a -> 16 бит
    i16 c16 = CBW(c);    // c -> 16 бит
    i32 a32 = CWD(a16);  // a -> 32 бита
    i32 c32 = CWD(c16);  // c -> 32 бита

    // Вычисление res1
    i16 x_div_a = IDIV(x32, a32);           // x / a (16 бит)
    i32 c_a_mul = IMUL(c16, a16);           // c * a (32 бита)
    i16 c_a_mul_16 = x32Tox16(c_a_mul);     // Приведение к 16 бит
    i16 sum1 = SUM(x_div_a, c_a_mul_16);    // x / a + c * a (16 бит)
    i16 res1 = ISUB(sum1, y);               // res1 = x / a + c * a - y (16 бит)

    // Вычисление res2
    i16 x_div_y = IDIV(x32, y32);           // x / y (16 бит)
    i16 c_div_a = IDIV(c32, a32);           // c / a (16 бит, в 32-битном формате)
    i16 sum2 = SUM(x_div_y, c_div_a);       // x / y + c / a (16 бит)
    i32 y_a_mul = IMUL(y, a16);             // y * a (32 бита)
    i16 y_a_div_x = IDIV(y_a_mul, x32);     // y * a / x (16 бит)
    i32 y_a_c_mul = IMUL(y_a_div_x, c16);   // (y * a / x) * c (32 бита)
    i16 y_a_c_mul_16 = x32Tox16(y_a_c_mul); // Приведение к 16 бит
    i16 res2 = ISUB(sum2, y_a_c_mul_16);    // res2 = x / y + c / a - (y * a / x) * c (16 бит)

    // Условие выбора результата
    i32 x_y_mul = IMUL(x, y);               // x * y (32 бита)
    i16 zero = CONST(0); 
	i32 zero_32 = CWD(zero);                // Константа 0 (16 бит)
    ICMPResult(x_y_mul, zero_32);           // Сравнение x * y с 0
    u1 cond = IGT;                          // Условие x * y > 0

    // Выбор результата
    RES = MSb16x2(res1, res2, cond);        // Если x * y > 0, выбираем res2, иначе res1
}

Мой профиль

Задача №18

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) b;
int __out __bits(16) R;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)

i16 SIGN(i16 A) { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS(i16 A) { return (A > 0) ? A : (A * (-1)); }
u1 NOT(u1 A) { return ~A; }
u1 OR2(u1 A, u1 B) { return A | B; }
u1 XOR2(u1 A, u1 B) { return A ^ B; }
u1 AND2(u1 A, u1 B) { return A & B; }

u16 CBW(u8 A) { return A; }
u32 CWD(u16 A) { return A; }
i16 x32Tox16(i32 A) { return A; }
i16 CONST(i16 A) { return A; }

i16 SUM(i16 A, i16 B) { i16 C; C = A + B; return C; }
i16 ISUB(i16 A, i16 B) { i16 C; C = A - B; return C; }
i32 IMUL(i16 A, i16 B) { i32 C; C = A * B; return C; }
i16 IDIV(i32 A, i32 B) { i16 C; C = A / B; return C; }

u16 MSb16x2(u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3 ICMP(i32 A, i32 B) { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A, B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

void main() {
    // Преобразование переменных к i32
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i32 a32 = CWD(a16);
    i16 b16 = CBW(b);
    i32 b32 = CWD(b16);

    // Первая ветка
    i16 x_minus_y = ISUB(x, y);               // x - y
    i32 x_minus_y_32 = CWD(x_minus_y);
    i16 x_minus_y_16 = x32Tox16(x_minus_y_32);
    i32 x_minus_y_a32 = IMUL(x_minus_y_16, a16); // (x - y) * a
    i16 x_minus_y_a16 = x32Tox16(x_minus_y_a32);

    i16 x_div_b = IDIV(x32, b32);             // x / b
    i16 res1 = SUM(x_minus_y_a16, x_div_b);   // res1 = (x - y) * a + (x / b)

    // Вторая ветка
    i16 x_plus_a = SUM(x, a16);               // x + a
    i32 x_plus_a_32 = CWD(x_plus_a);
    i16 y_minus_b = ISUB(y, b16);             // y - b
    i32 y_minus_b_32 = CWD(y_minus_b);
    i16 x_plus_a_div_y_minus_b = IDIV(x_plus_a_32, y_minus_b_32); // (x + a) / (y - b)

    i32 a_mul_b32 = IMUL(a16, b16);           // a * b
    i16 a_mul_b16 = x32Tox16(a_mul_b32);

    i16 res2 = SUM(x_plus_a_div_y_minus_b, a_mul_b16); // res2 = (x + a) / (y - b) + (a * b)

    // Условие выбора ветки
    ICMPResult(y32, x32);
    u1 cond = OR2(IEQ, IGT);                  // cond = (y >= x)

    // Выбор результата
    R = MSb16x2(res2, res1, cond);
}

Мой профиль

Обновление файла для AI:
https://docs.google.com/document/d/1cW-bztp_kyBYiifghDxx07MKQUDUYWzaeNbxhHsvrfU/edit?

Мой профиль

Задача №13 (решена с помощью:
https://bigmodel.cn/dev/api/normal-model/glm-4 - glm-4-plus) - с первой отправки решило правильно, но не учитывало некоторые правила с соблюдением размерности, ниже исправленный вариант:

int __in __bits(16) X;
int __in __bits(16) Y;
int __in __bits(8) A9;
int __in __bits(8) B7;
int __out __bits(16) RES;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

u16 CBW      (u8  A) {return A;}
u32 CWD      (u16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}
i16 CONST    (i16 A) {return A;}

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}

void main() {
 i32 X32 = CWD(X);
 i32 Y32 = CWD(Y);
 i16 A916 = CBW(A9);
 i32 A932 = CWD(A916);
 i16 B716 = CBW(B7);
 i32 B732 = CWD(B716);

 i16 zero16 = CONST(0);
 i32 zero32 = CWD(zero16);

 // Вычисление выражения для первой ветки: ((X - Y) * A9 + B7) / Y, если X * Y >= 0
 i16 X_minus_Y = ISUB(X, Y);
 i32 A9_X_minus_Y_mul = IMUL(X_minus_Y, A916);
 i16 A9_X_minus_Y_mul_16 = x32Tox16(A9_X_minus_Y_mul);
 i16 temp1 = SUM(A9_X_minus_Y_mul_16, B716);
 i32 temp1_32 = CWD(temp1);
 i16 res1 = IDIV(temp1_32, Y32);

 i16 Y_plus_X = SUM(Y, X);
 i32 Y_plus_X_32 = CWD(Y_plus_X);
 i16 temp2 = IDIV(Y_plus_X_32, A932);
 i16 temp3 = ISUB(temp2, B716);
 i32 temp3_32 = CWD(temp3);
 i16 res2 = IMUL(temp3_32, X);

 i32 XY_mul = IMUL(X32, Y32);
 ICMPResult(XY_mul, zero32);

 u1 cond = NOT(ILT);

 RES = MSb16x2(res2, res1, cond);
}

Мой профиль

Задача №8

// Объявление входных и выходных переменных
int __in __bits(16) X;
int __in __bits(16) Y;
int __in __bits(8) A9;
int __in __bits(8) B7;
int __out __bits(16) RES;

// Определение типов с помощью макросов
#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

// Библиотека функций C-MPA
i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

u16 CBW      (u8  A) { return A; }
u32 CWD      (u16 A) { return A; }
i16 CONST    (i16 A) { return A; }

i16 x32Tox16 (i32 A) { return A; }
i8  x16Tox8  (i16 A) { return A; }

i16 SUM      (i16 A, i16 B) { i16 C; C = A + B; return C; }
i16 ISUB     (i16 A, i16 B) { i16 C; C = A - B; return C; }
i32 IMUL     (i16 A, i16 B) { i32 C; C = A * B; return C; }
i16 IDIV     (i32 A, i32 B) { i16 C; C = A / B; return C; }

u16 MSb16x2  (u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3  ICMP     (i32 A, i32 B) { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1  IGT;
u1  IEQ;
u1  ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

void main() {
    // Приведение переменных к необходимым типам
    i32 X32 = CWD(X);
    i32 Y32 = CWD(Y);
    i16 A916 = CBW(A9);
    i16 B716 = CBW(B7);
    i32 A932 = CWD(A916);
    i32 B732 = CWD(B716);

    // Вычисление первой ветки: (Y + X * A9 - B7) / Y
    i32 XA9_mul = IMUL(X, A916);          // X * A9
    i16 XA9_mul_16 = x32Tox16(XA9_mul);  // Приведение результата к i16
    i16 term1_sum = SUM(Y, XA9_mul_16);  // Y + X * A9
    i16 term1_res = ISUB(term1_sum, B716); // Y + X * A9 - B7
    i32 term1_res_32 = CWD(term1_res);   // Приведение результата к i32
    i16 res1 = IDIV(term1_res_32, Y32);  // (Y + X * A9 - B7) / Y

    // Вычисление второй ветки: (Y + A9) * X / Y - B7
    i16 term2_sum = SUM(Y, A916);        // Y + A9
    i32 term2_mul = IMUL(term2_sum, X);  // (Y + A9) * X
    i16 term2_div = IDIV(term2_mul, Y32); // ((Y + A9) * X) / Y
    i16 res2 = ISUB(term2_div, B716);    // ((Y + A9) * X) / Y - B7

    // Проверка условия X * Y >= 0
    i32 XY_mul = IMUL(X, Y);             // X * Y
    i16 zero = CONST(0);
    i32 zero_32 = CWD(zero);

    ICMPResult(XY_mul, zero_32);
    u1 cond = OR2(IEQ, IGT);             // X * Y >= 0

    // Выбор результата на основе условия
    RES = MSb16x2(res2, res1, cond);
}