arcsaraiva

Prezados, Estou executando um código que está apresentando erro de segmentation fault em duas ocasiões distintas. Para executar são passados inúmeros parâmetros. Sendo a chamada assim: ./prog 7,3,1,0,1,3 13,4,1,0,1,3,9 0.1,0.1,10 20000 saida 1 91 onde as duas primeiras sequências de números são padrões pré definidos, a terceira sequência de números é a probabilidade, o quarto número é a quantidade de repetições em cada probabilidade, saida é o nome do arquivo txt de saída, 1 é padrão e o ultimo valor é o mmc entre o primeiro número das duas primeiras sequências (7 e 13). Na primeira ocasião é na chamada, após a primeira interação de um for de probabilidade, ou seja, na chamada passo 01.01.10 que quer dizer que inicie com 0.1, incremente em cada rodada 0,1 durante 10 vezes (vai de 10 a 100%). O 20000 é o número de repetições que serão executadas em cada probabilidade. Quando executo, as primeiras 20000 repetições com a probabilidade em 0.1 ocorrem corretamente e quando vai incrementar para probabilidade em 0.2 causa o erro de segmentation fault. Já tentei desalocar a memória utilizando free(pp) dentro deste for (linha 337) mas não funcionou e eu só desaloco a memória na linha 359. Para remediar isso, mudei a chamada de forma manual, ou seja, a cada chamada eu passo um valor de probabilidade, assim ficou: ./prog 7,3,1,0,1,3 13,4,1,0,1,3,9 0.1,0,1 20000 saida 1 91 que passo como probabilidade inicial 0.1, 0 de incremento e 1 única vez. Desta forma consegui fazer funcionar. Até que me deparei na segunda ocasião que é quando tenho um valor maior de mmc. Por exemplo: ./prog 133,12,1,0,9,10,12,26,30,67,74,82,109,114,120 183,14,1,0,12,19,20,22,43,60,71,76,85,89,115,121,168 0.1,0,1 20000 saida 1 24339 Ele executa algumas vezes e saí com segmentation fault. Já troquei vários tipos de int para double e nada. Um detalhe é que para executar é necessário ter instalado a biblioteca LIBGSL (sudo apt-get install libgsl0-dev). O código completo está em https://pastebin.com/vpMhPDP9 Como não tenho experiência em C++ e parte deste código foi me entregue pronto, só alterei nas funções genPP e na main.

Olá vangodp, sim, t_pp_bd é um struct. Mais acima tentei explicar com detalhes o que este código faz. Qualquer dúvida estou as ordens.

Olá Hazzu, quanto a reconstruir o código completo eu não posso, pois a única função que posso alterar é o genPP. Essa função recebe por parâmetros informações como dois padrões (compostos por total de slots, slots ativos) e o mmc. no First pattern o que eu faço é pegar o primeiro padrão, por exemplo, 7,3 e faço ele se repetir mmc (entre os dois padrões) vezes, logo no exemplo 7,3 sem repetição eu teria 1101000, já com repetição é só repetir ele 9 vezes. no second pattern eu faço a mesma coisa para o segundo padrão, por exemplo, 9,4. Logo sem repetição fica 1100100100, já com repetição é só repetir esse padrão 7 vezes. No comparation of pattern of offset 0 eu simplesmente comparo se os 1's dos dois padrões tem coincidências de localização e armazeno no offsetZero.coincidences e depois eu armazeno para os 0's qual é a próxima coincidência. Vou fazer um exemplo: padrão 7,3 => 110100011010001101000110100011010001101000110100011010001101000 padrão 9,4 = >110010010110010010110010010110010010110010010110010010110010010 offsetZero.coincidences[0]=0 offsetZero.coincidences[1]=1 offsetZero.coincidences[2]=7 offsetZero.coincidences[3]=10 offsetZero.coincidences[4]=22 .... offsetZero.index[0]=1 offsetZero.index[1]=1 offsetZero.index[2]=7 offsetZero.index[3]=7 offsetZero.index[4]=7 offsetZero.index[[5]=7 offsetZero.index[6]=7 offsetZero.index[7]=7 offsetZero.index[8]=10 offsetZero.index[[9]=10 offsetZero.index[10]=10 offsetZero.index[[11]=22 ... O problema está no second pattern offset for diefferent offset 0. Aqui é deslocado todo o segundo parttern até mmc vezes, então, por exemplo: offset 0 110100011010001101000110100011010001101000110100011010001101000 110010010110010010110010010110010010110010010110010010110010010 offset 1 110100011010001101000110100011010001101000110100011010001101000 011001001011001001011001001011001001011001001011001001011001001 offset 2 110100011010001101000110100011010001101000110100011010001101000 101100100101100100101100100101100100101100100101100100101100100 offset 3 110100011010001101000110100011010001101000110100011010001101000 010110010010110010010110010010110010010110010010110010010110010 ... Você pode perceber que o ultimo elemento retorna na primeira posição de forma circular. O que não sei fazer é armazenar os others.coicidences e orther.index para cada offset. Eu tentei criar mmc others.coicidences e others.index, através de um for, mas não funcionou e meu professor me deu a dica de vetores dinâmicos, mais não entendi bem como fazer. Se olhar com calma, a coincidência do offset 1 é diferente dos demais e logo os index também serão. O mesmo comportamento acontece com todos os demais offsets. Espero ter explicado melhor. Resumidamente eu preciso alterar estas linhas (eu acho): pp->others.coincidences = (int *) malloc(pattern->k * pattern2->k * sizeof(int)); pp->others.index = (int *) malloc(mmc * sizeof(int)); Para fazer com que sejam vetores dinâmicos, e alterar o second pattern offset for diefferent offset 0 para armazenar a cada offset várias coincidências e mmc index. Acredito que seja possível com vetores dinâmicos, pelo menos foi isto que meu professor indicou.

o problema está aqui. Eu preciso criar, com um for ou com um while, x ponteiros. Assim eu teria offsetZero.index1[0], offsetZero.index1[1]...offsetZero.index1[62], offsetZero.index2[0], ...offsetZero.index2[62], offsetZero.index3[0],... a minha dúvida é criar esses ponteiros. Serão mmc ponteiros com mmc elementos cada um. Todas, rsrs. Valorizo o trabalho das pessoas, sou humilde, não tenho muito dinheiro, e não sei programar, então, se eu tiver condições, pago sim, até porque vão surgir novos problemas e novas dúvidas até que este projeto esteja pronto. Hazzu, este é um simulador de padrões de offsets. O que ele faz é criar um pré processamento para armazenar os padrões em ponteiros e depois calcular quanto tempo até um próximo padrão. Vou tentar dar um exemplo pequeno: imagine dois padrões, um com 7 elementos e desses 7, 3 são 1's e os demais 0's e um segundo padrão com 9 elementos, sendo 4 1's e os demais 0's. Matematicamente, para rodar todos os possíveis offsets, eu preciso do mmc dos dois padrões, neste caso 63. Então visualmente eu tenho: 1º - 1101000 1101000 1101000 1101000... 2º - 110010010 110010010 110010010 110010010... Neste exemplo, repetindo cada sequência mmc vezes tenho a coincidência dos 1's em 12 posições. No main eu faço o sorteio de uma posição start e dela é calculado quanto tempo até a primeira coincidência de 1's. Repare que neste primeiro exemplo o offset entre os dois padrões é 0. Depois eu preciso andar com esse padrão mmc vezes. Por exemplo com offset 1 a sequência fica assim: 1º - 1101000 1101000 1101000 1101000... 2º - 0 110010010 110010010 110010010 11001001... Sempre o segundo padrão que desloca e é um ciclo, logo, o último elemento [62] passa para a primeira posição. O pré-processamento é justamente isso. Ele armazena as coincidências quando existe o casamento dos 1's dos dois padrões e no index ele já armazena qual a próxima coincidência. Então no exemplo do offset 0, o elemento 0 aponta para 0, o elemento 1 aponta para 1, os elementos 2 ao 10 apontam para o 10... Espero ter explicado. A função genPP nada mais é que a função gerador de padrões de pontos (genPP) que gera os padrões e os offsets. E nela que preciso alterar para armazenar as coincidências e os indexs.

Bom dia Herbert, desculpa a demora, mas meu monitor queimou e fui obrigado a esperar a transportadora. Vamos ver se eu entendi: onde eu aloca as estruturas já faço o malloc /* * Allocate structures. */ ... pp->offsetZero.index = (int *) malloc(mmc * sizeof(int)); para acessar a primeira posição eu uso offsetZero.index[0]. Se é isso eu já sabia. Meu problema seria fazer : algo como pp->offsetZero.indexX = (int *) malloc(mmc * sizeof(int)); onde esse X do index seria um número. Desta forma eu teria: offsetZero.index0 = com mmc posições offsetZero.index1 = com mmc posições offsetZero.index2 = com mmc posições ... sendo que o X do index também varia de 0 a mmc posições. Mudando de assunto: não sei se você já está trabalhando nesta época de isolamento social, mas se tiver tempo, estou disposto a tentar pagar por uma ajuda neste código, pois tenho um prazo curto para terminar, não gosto de programação e não sei, além de criar um bloqueio, pois tudo que faço dá erro, kkk Se tiver interesse, me fala!

Obrigado Herbert, pela maravilhosa explicação. Me ajudou a entender um pouco mais de C++ (já que eu entendo quase nada). Este código foi me passado por um professor e pediu para alterar de forma a fazer a alocação dinâmica do vetor others.coicidentes de forma que ele tenha de 0 até mmc. Vou postar toda a função: t_pp_bd * genPP(t_bd * pattern, t_bd * pattern2, int mmc) { //pattern tem os valores de k e v, onde v é o tamanho total do pattern e k as posições válidas, por exemplo: pattern 7,3 diz que são 7 posições sendo 3 com valor 1 (ou true). t_pp_bd * pp; int i, j, z, w, a, b, c, d, e, f, h, k, t, index, offset; /* * Allocate structures. */ pp = (t_pp_bd *) malloc(sizeof(t_pp_bd)); pp->offsetZero.coincidences = (int *) malloc(pattern->k * pattern2->k * sizeof(int)); //coincidentes verifica se o a posição k válida do pattern casa com a posição k válida do pattern2 pp->offsetZero.index = (int *) malloc(mmc * sizeof(int)); pp->others.coincidences = (int *) malloc(pattern->k * pattern2->k * sizeof(int)); /*for (int q=0; q<mmc; q++){ char n[4]; char str[20] = "others.coicidentes"; sprintf(n, "%d", q); strcat(str, n); printf("%s",str); //este print mostra que gerou o nome corretamente pp->str = (int *) malloc(mmc * sizeof(int)); }*/ pp->v = pattern->v; pp->k = pattern->k; pp->v = pattern2->v; pp->k = pattern2->k; /* * Creation of the MMC index for offset 0 */ // First pattern - aqui cria o primeiro pattern, por exemplo: 7,3 ficaria assim 1101000 a = 0; b = 0; int menor[mmc]; memset(menor, 0, mmc*sizeof(int)); while (a <= mmc/pattern->v) { for (c=0; c < pattern->k; c++){ menor[((pattern->onSlots[c] + a*pattern->v) % mmc)] = 1; } a++; } // Second pattern - aqui cria o primeiro pattern, por exemplo: 9,4 ficaria assim 1100100100 d = 0; e = 0; int maior[mmc]; memset(maior, 0, mmc*sizeof(int)); while (d < mmc/pattern2->v) { for (f=0; f < pattern2->k; f++){ maior[((pattern2->onSlots[f] + d*pattern2->v) % mmc)] = 1; e++; } d++; } // Comparation of pattern of offset 0 - aqui comprar se a posição z nos dois patterns possui o valor 1 e se positivo armazena o valor no vetor w=0; for (z=0; z < mmc; z++){ if ((menor[z] == 1) && (maior[z]==1)){ pp->offsetZero.coincidences[w] = z; pp->offsetZero.k++; w++; } } j = 0; pp->offsetZero.v = pp->v; for (i = 0; i < pp->offsetZero.k; i++) { while(j <= pp->offsetZero.coincidences[i]) { pp->offsetZero.index[j++] = pp->offsetZero.coincidences[i]; } } while(j < pp->v) { pp->offsetZero.index[j++] = 0; } // Second pattern offset for different offset 0 - int size = sizeof(maior)/sizeof(maior[0]); printf("size-> %d\n", size); w=0; for (int i=1; i < 4; i++){ // i < size int j, last; last = maior[size -1]; for (j = size-1; j >0; j--){ maior[j] = maior[j-1]; } maior[0] = last; } // Comparation of pattern of different offset 0 - aqui comprar se a posição z nos dois patterns possui o valor 1 e se positivo armazena o valor no vetor, porém com um deslocamento (offset) do pattern2. Por exemplo, com offset 2 o primeiro 1 do pattern2 começa na posição 2 e como é um ciclo, os zeros finais ocupam as posições anteriores: compara 1101000 com 0011001001 k=0; for (t=0; t < mmc; t++){ if ((menor[t] == 1) && (maior[t]==1)){ pp->others.coincidences[k] = t; //aqui deveria ser o nome others.coicidentes1[k] para offset 1,others.coicidentes2[k] para offset 2, ... pp->others.k++; k++; } } return(pp); } Nesta segunda comparação é que mora o problema, pois como no exemplo eu uso o mmc entre 7 e 9, este offset pode variar entre 0 e 62 (os patterns são repetidos até completar mmc posições, por exemplo, no caso do 7 ficaria 1101000 1101000 1101000 1101000 1101000...). Assim, eu preciso ter os vetores dinamicamente de acordo com o offset, pois quando eu tiver um offset, por exemplo, 11, eu tenho x coincidências entre os 1's do 7 e do 9. Como others.coincidences já é um vetor para mmc posições, pensei em apenas alterar o nome de acordo com cada offset (others.coincidences0, others.coincidences1, others.coincidences2) e depois fazer no comparation of pattern of different offset 0 algo como uma verificação se a posição [20] de others.coincidencesX for igual a t então others.coincidencesX[k] = t; Espero que assim fique mais claro o que pretendo fazer. Desde já agradeço pela disponibilidade.

Olá pessoal, Sou completamente inexperiente em programação e especialmente em C e C++, e estou tentando fazer um for que gere nomes de ponteiros sequenciais (estes ponteiros já são vetores), mas está retornando erro ao compilar (error: lvalue required as left operand of assignment pp->others.index + q= (int *) malloc(mmc * sizeof(int)); com uma seta para o sinal de =) . Estou fazendo: for (int q = 0; q < mmc; q++){ //valor resultante do mmc de 7 e 9 pp->others.index + q = (int *) malloc(mmc * sizeof(int)); } a intenção seria que eu tivesse others.index0, others.index1, ..., others.index62. Não consegui achar meu erro. Podem me ajudar?

Prezados, estou tentando fazer com que uma função que incremente duas variáveis (w e offset) que inicia no 0 e é populada de acordo com um array pré-existente. Funciona bem em quanto o array existe, porém em um dos loops, estoura o tamanho do array. Por exemplo, no código abaixo meu array possui apenas 6 elementos e seus valores são 0, 1, 3, 7, 10 e 15 nas posições de 0 a 5, porém na execução em dado momento o w e o offset recebe o valor 6 e retorna exceção de ponto flutuante. Troquei o incremento de posição varias vezes sem exito. t_pp_bd * genPP(t_bd * pattern, t_bd * pattern2, int mmc) { t_pp_bd * pp; int i, j, z, k, a, b, c, index, offset; /* * Allocate structures. */ pp = (t_pp_bd *) malloc(sizeof(t_pp_bd)); pp->offsetZero.coincidences = (int *) malloc(pattern->k * sizeof(int)); pp->offsetZero.index = (int *) malloc(pattern->v * sizeof(int)); pp->others.coincidences = (int *) malloc(sizeof(int)); pp->others.index = (int *) malloc(pattern->v * sizeof(int)); pp->v = pattern->v; pp->k = pattern->k; pp->v = pattern2->v; pp->k = pattern2->k; /* * Creation of the MMC index for offset 0 */ // First pattern -> aqui é geradoum padrão do tipo 110110110110110... z = 0; j = 0; int menor[mmc]; memset(menor, 0, mmc*sizeof(int)); while (z < mmc/pattern->v) { for (i=0; i <= pattern->k; i++){ menor[(pattern->onSlots[i] + z*pattern->v) % mmc] = 1; //printf("menor %d-> %d\n",j, menor[j]); j++; }; z++; } // Second pattern -> aqui é gerado um padrão 110100011010001101000... a = 0; b = 0; int maior[mmc]; memset(maior, 0, mmc*sizeof(int)); while (a < mmc/pattern->v) { for (c=0; c < pattern2->k; c++){ maior[((pattern2->onSlots[c] + a*pattern2->v) % mmc)] = 1; //printf("maior %d-> %d\n",b, maior[b]); b++; } a++; } // Comparation of pattern of offset 0 -> nessa função verifica as posições onde os 1´s coincidem até 21 (0,1,3,7,10 e 15) int w=0; for (k=0; k < mmc; k++){ printf("W= %d\n",w); printf("offsetZero = %d\n",pp->offsetZero.k); printf("-------------------"); if ((menor[k] == 1) && (maior[k]==1)){ //a ideia é fazer qie offsetZero.coicidences[w] armazene na posição 0 o valor 0, na posição 1 o valor 1, na posição 2 o valor 3, na posição 4 o valor 7, na posição 5 o valor 10... printf("ACHOU em %d, menor %d, maior %d\n",k, menor[k], maior[k]); pp->offsetZero.coincidences[w] = k; printf("W= %d\n",w); printf("offsetZero = %d\n",pp->offsetZero.k); pp->offsetZero.k++; w++; printf("-------------------"); printf("W= %d\n",w); printf("offsetZero = %d\n",pp->offsetZero.k); j = 0; for (i = 0; i < pp->offsetZero.k; i++) { while(j <= pp->offsetZero.coincidences[i]) { pp->offsetZero.index[j++] = i; } } while(j < pp->v) { pp->offsetZero.index[j++] = 0; } } } return(pp); } O problema é que durante a execução, o k e o offset recebem o valor 6 (que deveria ir até o 5) e acontece a exceção. Alguém poderia me ajudar?

Prezados, estou tentando fazer com que uma função que incremente duas variáveis (w e offset) que inicia no 0 e é populada de acordo com um array pré-existente. Funciona bem em quanto o array existe, porém em um dos loops, estoura o tamanho do array. Por exemplo, no código abaixo meu array possui apenas 6 elementos e seus valores são 0, 1, 3, 7, 10 e 15 nas posições de 0 a 5, porém na execução em dado momento o w e o offset recebe o valor 6 e retorna exceção de ponto flutuante. Troquei o incremento de posição varias vezes sem exito. t_pp_bd * genPP(t_bd * pattern, t_bd * pattern2, int mmc) { t_pp_bd * pp; int i, j, z, k, a, b, c, index, offset; /* * Allocate structures. */ pp = (t_pp_bd *) malloc(sizeof(t_pp_bd)); pp->offsetZero.coincidences = (int *) malloc(pattern->k * sizeof(int)); pp->offsetZero.index = (int *) malloc(pattern->v * sizeof(int)); pp->others.coincidences = (int *) malloc(sizeof(int)); pp->others.index = (int *) malloc(pattern->v * sizeof(int)); pp->v = pattern->v; pp->k = pattern->k; pp->v = pattern2->v; pp->k = pattern2->k; /* * Creation of the MMC index for offset 0 */ // First pattern -> aqui é geradoum padrão do tipo 110110110110110... z = 0; j = 0; int menor[mmc]; memset(menor, 0, mmc*sizeof(int)); while (z < mmc/pattern->v) { for (i=0; i <= pattern->k; i++){ menor[(pattern->onSlots[i] + z*pattern->v) % mmc] = 1; //printf("menor %d-> %d\n",j, menor[j]); j++; }; z++; } // Second pattern -> aqui é gerado um padrão 110100011010001101000... a = 0; b = 0; int maior[mmc]; memset(maior, 0, mmc*sizeof(int)); while (a < mmc/pattern->v) { for (c=0; c < pattern2->k; c++){ maior[((pattern2->onSlots[c] + a*pattern2->v) % mmc)] = 1; //printf("maior %d-> %d\n",b, maior[b]); b++; } a++; } // Comparation of pattern of offset 0 -> nessa função verifica as posições onde os 1´s coincidem até 21 (0,1,3,7,10 e 15) int w=0; for (k=0; k < mmc; k++){ printf("W= %d\n",w); printf("offsetZero = %d\n",pp->offsetZero.k); printf("-------------------"); if ((menor[k] == 1) && (maior[k]==1)){ //a ideia é fazer qie offsetZero.coicidences[w] armazene na posição 0 o valor 0, na posição 1 o valor 1, na posição 2 o valor 3, na posição 4 o valor 7, na posição 5 o valor 10... printf("ACHOU em %d, menor %d, maior %d\n",k, menor[k], maior[k]); pp->offsetZero.coincidences[w] = k; printf("W= %d\n",w); printf("offsetZero = %d\n",pp->offsetZero.k); pp->offsetZero.k++; w++; printf("-------------------"); printf("W= %d\n",w); printf("offsetZero = %d\n",pp->offsetZero.k); j = 0; for (i = 0; i < pp->offsetZero.k; i++) { while(j <= pp->offsetZero.coincidences[i]) { pp->offsetZero.index[j++] = i; } } while(j < pp->v) { pp->offsetZero.index[j++] = 0; } } } return(pp); } O problema é que durante a execução, o k e o offset recebem o valor 6 (que deveria ir até o 5) e acontece a exceção. Alguém poderia me ajudar?

Prezados, estou tentando criar um array que já contenha um determinado valor para todas as posições. z = 0; j = 0; //int menor[pattern2->v * pattern->k]; int menor[mmc] = {0}; // este array deveria iniciar com mmc posições, TODAS contendo o valor int 0 while (z < mmc/2) { printf("z -> %d\n",z); for (i=0; i < pattern->k; i++){ menor[(pattern->onSlots[i] + z*pattern->v) % mmc] = 1; // esta função substitui em alguns indices o 0 por int 1 printf("menor %d-> %d\n",j, menor[j]); j++; }; z++; } na criação do array (acho que estou fazendo errado) informa 3 erros ao compilar: bd2_r.c:65:2: error: variable-sized object may not be initialized int menor[mmc] = {0}; ^~~ bd2_r.c:65:20: warning: excess elements in array initializer int menor[mmc] = {0}; ^ bd2_r.c:65:20: note: (near initialization for ‘menor’) Como este é meu primeiro programa em C++ e estou aprendedo, será que alguém poderia me esclarecer como eu posso criar este array com todos os valores em 0? Desde já agradeço.

Olá, estou iniciando em c++ e estou tentando ajustar um código que não está rodando como deveria. Tenho uma função com os seguintes comandos: bool padrão[100]; int contador = 0; padrão[0] = padrão[10] = padrão[35]= padrão[83] = 1; //ou esta linha não funciona if (padrão[contador] != 1){ //ou esta, pois o resultado é inesperado  cout << "dentro if" << contador << endl; contador++; } else {  cout << "no else" << contador << endl; contador++; } Reparem que eu preciso do array com 100 índices, porém só os declarados são usados (0,10,35,83). Ao executar este código, dentro if aparece nos índices 0,1, 2, 5, 8, 9, 10,13,16,... e o no else nos índices 3,4,6,7,11,12,14,15, ... Poderiam me auxiliar?