bool example1_rx(const std::string& dataaddress, unsigned short dataport, std::atomic_bool& stopFlag)
{
SuperBlock rxBlock;
uint8_t rawBlock[sizeof(SuperBlock)];
int rawBlockSize;
UDPSocket rxSocket(dataport);
std::string senderaddress, senderaddress0;
unsigned short senderport, senderport0 = 0;
Example1Rx ex1(nbSamplesPerBlock, nbOriginalBlocks, nbRecoveryBlocks);
std::cerr << "example1_rx: receiving on address: " << dataaddress << " port: " << (int) dataport << std::endl;
while (!stopFlag.load())
{
rawBlockSize = 0;
while (rawBlockSize < sizeof(SuperBlock))
{
rawBlockSize += rxSocket.RecvDataGram((void *) &rawBlock[rawBlockSize], (int) sizeof(SuperBlock), senderaddress, senderport);
if ((senderaddress != senderaddress0) || (senderport != senderport0))
{
std::cerr << "example1_rx: connected to: " << senderaddress << ":" << senderport << std::endl;
senderaddress0 = senderaddress;
senderport0 = senderport;
}
usleep(10);
}
rxBlock = *((SuperBlock *) rawBlock);
ex1.processBlock(rxBlock);
}
}
TEST(AsyncSocketException, SimpleTest) {
AsyncSocketException ex1(
AsyncSocketException::AsyncSocketExceptionType::NOT_OPEN,
"test exception 1");
EXPECT_EQ(
AsyncSocketException::AsyncSocketExceptionType::NOT_OPEN, ex1.getType());
EXPECT_EQ(0, ex1.getErrno());
EXPECT_EQ(
"AsyncSocketException: test exception 1, type = Socket not open",
std::string(ex1.what()));
AsyncSocketException ex2(
AsyncSocketException::AsyncSocketExceptionType::BAD_ARGS,
"test exception 2",
111 /*ECONNREFUSED*/);
EXPECT_EQ(
AsyncSocketException::AsyncSocketExceptionType::BAD_ARGS, ex2.getType());
EXPECT_EQ(111, ex2.getErrno());
EXPECT_EQ(
"AsyncSocketException: test exception 2, type = Invalid arguments, "
"errno = 111 (Connection refused)",
std::string(ex2.what()));
}
int main(){
int menu;
do {
printf("\n\nEscolha 1 exercicio de 1 - 10, entre 0 para sair: \n--> ");
scanf("%d", &menu);
switch(menu){
case 1: {
ex1();
break;
}
case 2: {
ex2();
break;
}
case 3: {
int mat[5][5];
matrixFill(5, 5, mat);
printf("A media dos elementos abaixo da diagonal principal e %d.", (float)mediaAr(5, 5, mat));
break;
}
case 4: {
ex4();
break;
}
case 5: {
ex5();
break;
}
case 6: {
ex6();
break;
}
case 7: {
ex7();
break;
}
case 8: {
ex8();
break;
}
case 9: {
ex9();
break;
}
case 10: {
ex10();
break;
}
default: {
printf("Opcao invalida.\n");
break;
}
}
} while (menu != 0);
return 0;
}
static void set(UnalignedMatrix44<T>& mat, bpy::tuple indices, const T v)
{
if (bpy::len(indices) != 2)
{
PyErr_SetString(PyExc_RuntimeError, "Invalid tuple length given to appleseed.Matrix.__set_item__");
bpy::throw_error_already_set();
}
int i, j;
bpy::extract<int> ex0(indices[0]);
if (!ex0.check())
{
PyErr_SetString(PyExc_TypeError, "Incompatible index type. Only ints.");
bpy::throw_error_already_set();
}
else
i = ex0();
bpy::extract<int> ex1(indices[1]);
if (!ex1.check())
{
PyErr_SetString(PyExc_TypeError, "Incompatible index type. Only ints.");
bpy::throw_error_already_set();
}
else
j = ex1();
if (i < 0)
i = 4 + i;
if (j < 0)
j = 4 + j;
if (i >= 0 && i < 4 && j >= 0 && j < 4)
mat(i, j) = v;
else
{
PyErr_SetString(PyExc_IndexError, "Out of bounds access in appleseed.Matrix.__set_item__");
boost::python::throw_error_already_set();
}
}
void ex()
{
printf("Введите номер задания (1 или 2 или q для выхода):\n");
char c;
scanf("\n%c",&c);
switch (c)
{
case '1': ex1();break;
case '2': ex2();break;
case 'q': return;break;
default : break;
}
}
int
sc_main( int argc, char* argv[] )
{
sc_signal<int> a("a");
sc_signal<int> b("b");
sc_signal<int> c("c");
sc_clock clk("clk", 10, SC_NS);
example ex1("ex1");
ex1(clk, a, b, c);
tb tbb1("tbb1");
tbb1(clk, a);
tb2 tbb2("tbb2");
tbb2(clk, b);
monitor mon("mon", a, b, c);
sc_start(200, SC_NS);
return 0;
}
int st(struct parser* p)
{
if (!identifier(p)) {
return 0;
}
label(p->id);
character(p, '=');
ex1(p);
lstring(p, ".,");
out1("R");
return 1;
}
TEST( NamespaceTest, ExtraName ) {
Namespace foo( "foo.bar" );
ASSERT_FALSE( foo.isExtra() );
string str0 = foo.extraName( 0 );
ASSERT_EQUALS( "foo.bar$extra", str0 );
Namespace ex0( str0 );
ASSERT_TRUE( ex0.isExtra() );
string str1 = foo.extraName( 1 );
ASSERT_EQUALS( "foo.bar$extrb", str1 );
Namespace ex1( str1 );
ASSERT_TRUE( ex1.isExtra() );
}
int main()
{
try
{
ex1();
ex2();
ex3();
ex4();
ex5();
}
catch(SQLException& e)
{
std::cerr << e.message() << std::endl;
}
return 0;
}
void tst_algebraic() {
// enable_trace("resultant_bug");
// enable_trace("poly_sign");
disable_trace("algebraic");
// enable_trace("mpbq_bug");
// enable_trace("mpz_mul2k");
// enable_trace("mpz_gcd");
tst_root();
tst_isolate_roots();
ex1();
tst_eval_sign();
tst_select_small();
tst_dejan();
tst_wilkinson();
tst1();
tst_refine_mpbq();
}
int ex3(struct parser* p)
{
int label_1 = label_count++;
whitespace(p);
if (lstring(p, ".ID")) {
out1("ID");
return 1;
}
else if (lstring(p, ".NUMBER")) {
out1("NUM");
return 1;
}
else if (lstring(p, ".STRING")) {
out1("SR");
return 1;
}
else if (lstring(p, ".EMPTY")) {
out1("SET");
return 1;
}
else if (lstring(p, "(")) {
ex1(p);
lstring(p, ")");
return 1;
}
else if (*(p->buf->begin) == '$') {
p->buf->begin++;
generate_label(label_1);
ex3(p);
out3("BT", label_1);
out1("SET");
return 1;
}
else if (identifier(p)) {
out2("CLL", p->id);
return 1;
}
else if (string(p)) {
out2("TST", p->id);
return 1;
}
return 0;
}
int main(int argc, char **argv) {
print("LISTA DE EXERCICIOS DE FDA - 02");
ex1();
ex2();
ex3();
ex4();
ex5();
ex6();
ex7();
ex8();
ex9();
ex10();
ex11();
ex12();
ex13();
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2 || strcmp("-h", (const char *)argv[1]) == 0 || strcmp("--help", (const char *)argv[1]) == 0) {
print_usage();
return 1;
}
if (strcmp("ex1", (const char *)argv[1]) == 0)
ex1();
else if (strcmp("ex2", (const char *)argv[1]) == 0)
ex2();
else if (strcmp("ex3", (const char *)argv[1]) == 0)
ex3();
else if (strcmp("ex4", (const char *)argv[1]) == 0)
ex4();
else
print_usage();
return 0;
}
int main(int argc, char* argv[]) {
int ex = getExerciseNumber(argc, argv);
switch (ex){
case 1 :
ex1();
return 0;
case 2:
ex2();
return 0;
case 3:
ex3();
return 0;
case 4:
ex4();
return 0;
default:
printf("\n The exercise does not exist!\n");
printf("You specified exercise: %d", ex);
return 0;
}
}
void ex3() {
if (is_token(TOKEN_ID)) {
emit_op(OP_CLL, lexval);
} else if (is_token(TOKEN_STRING)) {
emit_op(OP_TST, lexval);
} else if (is_token(TOKEN_ID_LITERAL)) {
emit(OP_ID);
} else if (is_token(TOKEN_NUMBER)) {
emit(OP_NUM);
} else if (is_token(TOKEN_STRING)) {
emit(OP_SR);
} else if (is_token(TOKEN_OPEN_PAREN)) {
ex1();
is_token(TOKEN_CLOSE_PAREN);
} else if (is_token(TOKEN_EMPTY)) {
op(OP_SET);
} else if (is_token(TOKEN_SEQ)) {
// output label *1
ex3();
emit_op(OP_BT, label1);
emit(OP_SET);
}
}
bool example1_tx(const std::string& dataaddress, int dataport, std::vector<int> &blockExclusionList, std::atomic_bool& stopFlag)
{
SuperBlock txBlocks[256];
Example1Tx ex1(nbSamplesPerBlock, nbOriginalBlocks, nbRecoveryBlocks);
std::cerr << "example1_tx: transmitting on address: " << dataaddress << " port: " << dataport << std::endl;
for (uint16_t frameNumber = 0; !stopFlag.load(); frameNumber++)
{
ex1.makeDataBlocks(txBlocks, frameNumber);
if (!ex1.makeFecBlocks(txBlocks, frameNumber))
{
std::cerr << "example1_tx: encode error" << std::endl;
break;
}
ex1.transmitBlocks(txBlocks, dataaddress, dataport, blockExclusionList, 300);
std::cerr << ".";
}
return true;
}
LRESULT CALLBACK WindowProcedure (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
POINT coord;
static segment *s;
static cerc *c;
switch (message) /* handle the messages */
{
case WM_CREATE:
addMenu(hWnd);
// Generez doua puncte, un segment si un cerc
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId) {
case IDM_EXERCITIU_1:
current = 1;
ex1(hWnd);
break;
case IDM_EXERCITIU_2:
current = 2;
ex2(hWnd);
break;
case IDM_EXERCITIU_3:
current = 3;
clicks = 0;
L.clear();
InvalidateRect (hWnd, NULL, TRUE);
UpdateWindow (hWnd);
break;
case IDM_EOL:
clicks = 0;
break;
case IDM_CLEAR:
current = 0;
L.clear();
InvalidateRect (hWnd, NULL, TRUE);
UpdateWindow (hWnd);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
current = 0;
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_LBUTTONDOWN:
if(current == 3) {
GetCursorPos(&coord);
// Preiau coord. cursorului f. de coltul zonei client
ScreenToClient(hWnd, (LPPOINT) &coord);
if( clicks == 0 ) {
s = new segment();
s->setX(coord.x);
s->setY(coord.y);
} else {
s->setDx(coord.x - s->getX());
s->setDy(coord.y - s->getY());
s->setColor(color);
L.push_back(s);
InvalidateRect (hWnd, NULL, TRUE);
UpdateWindow (hWnd);
s = new segment();
s->setX(coord.x);
s->setY(coord.y);
}
clicks++;
} else if(current == 4) {
GetCursorPos(&coord);
// Preiau coord. cursorului f. de coltul zonei client
ScreenToClient(hWnd, (LPPOINT) &coord);
if( clicks == 0 ) {
c = new cerc();
c->setX(coord.x);
c->setY(coord.y);
clicks++;
} else {
int dx = (coord.x - c->getX());
int dy = (coord.y - c->getY());
c->setR(sqrt(dx*dx + dy*dy));
c->setColor(color);
L.push_back(c);
InvalidateRect (hWnd, NULL, TRUE);
UpdateWindow (hWnd);
clicks = 0;
}
}
break;
case WM_KEYDOWN:
switch (wParam) {
case VK_END:
clicks = 0;
break;
case 'r': case 'R':
color = RGB(255, 0, 0); // Desenez cu rosu
break;
case 'g': case 'G':
color = RGB(0, 255, 0); // Desenez cu verde
break;
case 'b': case 'B':
color = RGB(0, 0, 255); // Desenez cu albastru
break;
case 's': case 'S':
current = 3;
clicks = 0;
break;
case 'c': case 'C':
current = 4;
clicks = 0;
break;
}
break;
case WM_PAINT: {
hdc = BeginPaint(hWnd, &ps);
std::list<punct*>::iterator it;
for (it=L.begin(); it!=L.end(); ++it){
(*it)->draw(hdc);
}
EndPaint(hWnd, &ps);
UpdateWindow(hWnd);
}
break;
case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
default: /* for messages that we don't deal with */
return DefWindowProc (hWnd, message, wParam, lParam);
}
return 0;
}
int main (){
int menu, exit = 0;
setlocale(LC_ALL, "");
while(!exit){
printf("\t \n \n Escolha um exercicio:");
printf("\t \t \n 1.Calcula maior elemento da matriz e divide os elementos por ele");
printf("\t \t \n 2.Realiza trocas com a matriz 10x10");
printf("\t \t \n 3.Retorna media aritimetica dos elementos abaixo da diagonal principal");
printf("\t \t \n 4.Recebe matriz e mostra elementos cujo a soma da linha com coluna e impar");
printf("\t \t \n 5.Verifica se uma matriz A e a transposta de uma matriz B");
printf("\t \t \n 6.Verifica se uma matriz e simetrica");
printf("\t \t \n 7.Gera matrizes simetricas");
printf("\t \t \n 8.Encontrar elemento minimax de matriz");
printf("\t \t \n 9.Recebe matriz de caracteres e procura por string");
printf("\t \t \n 10.Verifica se a matriz e inca");
printf("\t \t \n0.Sair");
printf("\n \t Opcao >> ");
scanf("%d", &menu);
switch(menu){
case 1:{
ex1();
break;
}
case 2:{
ex2();
break;
}
case 3:{
ex3();
break;
}
case 4:{
ex4();
break;
}
case 5:{
ex5();
break;
}
case 6:{
ex6();
break;
}
case 7:{
ex7();
break;
}
case 8:{
ex8();
break;
}
case 9:{
ex9();
break;
}
case 10:{
ex10();
break;
}
case 0:{
exit = 1;
break;
}
default:{
printf("\t\t\t\nOpcao Invalida.\n\n\n");
break;
}
}
}
}
