Psst.. new poll here.
Psst.. new forums here.
Microsoft is blocking us again (TY IP Reputation!) so just use oauth login instead. :)
Paste
Pasted as C by Ezekiel ( 6 years ago )
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
typedef struct Core
{
// char peptideStr[50]; //Cadena Péptido
// char coreStr[10]; //Cadena Core
// float *core; //[9 * nPSMM]; //Core Codificado
// float *PFRR; //[1 * nPSMM]; //Región Flanqueante Derecha
// float *PFRL; //[1 * nPSMM]; //Región Flanqueante Izquierda
// float *lenP; //[2]; //Longitud del péptido
// float *lenR; //[2]; //Longitud de la Región Flanqueante Derecha
// float *lenL; //[2]; //Longitud de la Región Flanqueante Izquierda
// float affinity; //Afinidad del core
// int selected; //Indicador del Core con Menor Error
float *coreConcatenate; //[(9 * nPSMM) + (2 * nPSMM) + 6] //Todo el conjunto
//Por el momento solo se usará coreConcatenate, affinity y selected
} Core;
typedef struct Peptide
{
char string[500];
float affinity;
int coreN;
Core *core;
} Peptide;
//Genera un float[24] con puros zeros
float *GenerateZeros(int sizeEncode)
{
float *array = malloc(sizeof(float) * sizeEncode);
int i;
for (i = 0; i < sizeEncode; i++)
{
array[i] = 0.0000000f;
}
return array;
}
//Devuelve el promedio en un float[24] de todas las codificaciones de la PFR (Regiones Flanqueantes)
float *GenerateMean(int sizeEncode, int len, float* array[])
{
float *mean = malloc(sizeof(float) * sizeEncode);
int i;
for (i = 0; i < sizeEncode; i++)
{
float suma = 0.0f;
int j = 0;
for(j = 0; j < len; j++)
suma += array[j][i];
mean[i] = suma/len;
}
return mean;
}
//Codifica un aminoácido con un filename blosum paramétrico
float *Encode(char letter, char *fileNameBlosum, int sizeEncode)
{
float *array = malloc(sizeof(float) * sizeEncode);
char cad[256];
char c;
FILE *dataFile = fopen(fileNameBlosum, "r");
int i = 0, iArray = 0, indice = 0, band = 0;
while (!feof(dataFile))
{
c = fgetc(dataFile);
if (i >= 1) //i = 0 es encabezado
{
if (band == 1) //se prende cuando encontró la letra a codificar
{
if (c == ',' || c == '\n')
{
cad[indice] = '\0';
array[iArray] = atof(cad);
indice = 0;
iArray++;
if(c == '\n'){ //apagar cuando ya codificó todos los números
band = 0;
break;
}
}else{
cad[indice] = c;
indice++;
}
}
if (c == letter)
{
band = 1;
c = fgetc(dataFile);
}
}
else if (c == '\n')
{
i++;
}
}
fclose(dataFile);
return array;
}
//Codifica el Core
float *EncodeCore(char *core, char *fileNameBlosum, int sizeEncode){
int i = 0, j = 0;
float *coreEncode = malloc(sizeof(float ) * 9 * sizeEncode);
for(i = 0; i < 9; i++){
float *encode = Encode(core[i], fileNameBlosum, sizeEncode);
for(j = 0; j < sizeEncode; j++){
coreEncode[i*sizeEncode + j] = encode[j];
}
}
return coreEncode;
}
//Concatena en un float[] todas las entradas para la RNA, para blosum62 270 entradas
float *Concatenate(float* core, float* PFRR, float* PFRL, float* lenP, float* lenR, float* lenL, int sizeEncode){
int lc = 9*sizeEncode; //Longitud del Core
float *concatenate = malloc(sizeof(float) * ((lc) + (2 * sizeEncode) + 6));
int i = 0, iC = 0;
// int lenCore = sizeof(core)/sizeof(float);
// printf("%d\n", lenCore);
// int lenPFRR = sizeof(PFRR)/sizeof(float);
// printf("%d\n", lenPFRR);
// int lenPFRL = sizeof(PFRL)/sizeof(float);
// printf("%d\n\n", lenPFRL);
for(i = 0; i < lc; i++){
concatenate[iC] = core[i];
iC++;
}
for(i = 0; i < sizeEncode; i++){
concatenate[iC] = PFRR[i];
iC++;
}
for(i = 0; i < sizeEncode; i++){
concatenate[iC] = PFRL[i];
iC++;
}
concatenate[iC] = lenP[0];
concatenate[iC+1] = lenP[1];
concatenate[iC+2] = lenR[0];
concatenate[iC+3] = lenR[1];
concatenate[iC+4] = lenL[0];
concatenate[iC+5] = lenL[1];
return concatenate;
}
//Devuelve todos los Cores de un péptido
Core* GetCores(char *peptideStr, char *fileNameBlosum, int nCores, int sizeEncode)
{
Core *core = malloc(sizeof(Core) * nCores);
int i = 0;
for (i = 0; i < nCores; i++)
{
char coreStr[30];
int j = 0;
for (j = 0; j < 9; j++)
{
//Formar el core de 9 aminoácidos
coreStr[j] = peptideStr[i + j];
}
coreStr[9] = '\0';
//printf("CORE %s", coreStr);
//Encontrar el índice inicio y final del core dentro del péptido
int iindex = 0, eindex = 0;
char *pfound = strstr(peptideStr, coreStr); //pointer to the first character found 's' in the string peptideStr
if (pfound != NULL)
{
iindex = pfound-peptideStr; //peptideStr is already pointing to the first string character 't'.
}
eindex = iindex + 9;
///Encontrar Regiones Flanqueantes Derecha e Izquierda
float *PFRR;//PFR Derecha
int lPFRR = 0; //Longitud del PFR
//NO TIENE RFP derecha
if (eindex == strlen(peptideStr))
{
PFRR = GenerateZeros(sizeEncode);
}
else
{
//Tiene PFRR mayor a 3 aminoácidos
char *strPFRRight = malloc(sizeof(char) * 20);
int indice = 0;
for (j = eindex; j < strlen(peptideStr); j++)
{
strPFRRight[indice] = peptideStr[j];
indice++;
}
strPFRRight[indice] = '\0';
//Cambiará la longitud de 48 si es con otro BLOSUM
if (strlen(strPFRRight) >= 3)
{
float *codecs[3]; //La longitud del arreglo es de 3
for (j = 0; j < 3; j++){
codecs[j] = Encode(strPFRRight[j], fileNameBlosum, sizeEncode);
}
lPFRR = 3;
PFRR = GenerateMean(sizeEncode, 3, codecs);
}
else //Tiene PFRR menor a 3 aminoácidos
{ float *codecs[strlen(strPFRRight)]; //La longitud del arreglo es lo que mida el PFRR
for(j = 0; j < strlen(strPFRRight); j++){
codecs[j] = Encode(strPFRRight[j], fileNameBlosum, sizeEncode);
}
lPFRR = strlen(strPFRRight);
PFRR = GenerateMean(sizeEncode, strlen(strPFRRight), codecs);
}
}
float *PFRL;
int lPFRL = 0;
//Hasta aquí se imprime información, después dice "*** buffer overflow detected ***: "
//NO TIENE RFP izquierda
if(iindex == 0){
PFRL = GenerateZeros(sizeEncode);
}else{
char *strPFRLeft = malloc(sizeof(char) * 20);
int indice = 0;
for (j = 0; j < iindex; j++)
{
strPFRLeft[indice] = peptideStr[j];
indice++;
}
strPFRLeft[indice] = '\0';
//printf("%s", strPFRLeft);
//printf("%d", strlen(strPFRLeft));
// fflush(stdout);
if (strlen(strPFRLeft) >= 3)
{
float *codecs[3]; //La longitud del arreglo es de 3
indice = 0;
for(j = 0; j < 3; j++){
//printf("%d", j);
// printf("%s", &strPFRLeft[j]);
// fflush(stdout);
codecs[indice] = Encode(strPFRLeft[j], fileNameBlosum, sizeEncode);
indice++;
}
lPFRL = 3;
PFRL = GenerateMean(sizeEncode, 3, codecs);
}
else
{
float *codecs[strlen(strPFRLeft)];
indice = 0;
for(j = 0; j < strlen(strPFRLeft); j++){
codecs[indice] = Encode(strPFRLeft[j], fileNameBlosum, sizeEncode);
indice++;
}
lPFRL = strlen(strPFRLeft);
PFRL = GenerateMean(sizeEncode, strlen(strPFRLeft), codecs);
}
}
float lpep = 1/(1+exp((strlen(peptideStr)-15)/2));
float lenP[2] = {lpep, 1-lpep};
float lenR[2] = {lPFRR/3, 1-lPFRR/3};
float lenL[2] = {lPFRL/3, 1-lPFRL/3};
float *coreEncode = EncodeCore(coreStr, fileNameBlosum, sizeEncode);
//core[i].affinity = 0.0f;
//strcpy(core[i].coreStr,coreStr);
//core[i].selected = 0;
float *concatenate;
concatenate = Concatenate(coreEncode, PFRR, PFRL, lenP, lenR, lenL, sizeEncode);
core[i].coreConcatenate = concatenate;
}
return core;
}
//Devuelve todos los péptidos con sus Cores
Peptide* CoresInPeptide(char *fileNameDB, char **alleles, char *fileNameBlosum, int N, int sizeEncode)
{
Peptide *peptides;
peptides = malloc(sizeof(Peptide) * N);
int nAlleles = 1;
FILE *dataFile;
int comma = 0, i = 0, r = 0;
char c;
char peptideStr[256];
char affinity[256];
char allele[256];
dataFile = fopen(fileNameDB, "r");
while (!feof(dataFile))
{
c = fgetc(dataFile);
//Leer primera columna Peptido
if (comma == 0 && c != ',')
{
peptideStr[i] = c;
i++;
}
//Leer segunda columna Afinidad
if (comma == 1 && c != ',')
{
affinity[i] = c;
i++;
}
//Leer tercera columna Allelo
if (comma == 2 && c != '\n')
{
allele[i] = c;
i++;
}
if (c == ',')
{
if (comma == 0){
peptideStr[i] = '\0'; //Aplicar fin de cadena
}
if (comma == 1){
affinity[i] = '\0'; //Aplicar fin de cadena
}
i = 0;
comma++;
}
if (c == '\n')
{
allele[i] = '\0'; //Aplicar fin de cadena
int j;
j = 0;
for (j = 0; j < nAlleles; j++)
{
//Validar si es un alelo de los alelos seleccionados y transformar
if (strcmp(alleles[j], allele) == 0)
{
//Verificar que la longitud del Péptido sea mayor a 9
if (strlen(peptideStr) >= 9)
{
//printf("peptido: %s, affinidad: %s, alelo: %s\n", peptideStr, affinity, allele);
//copiar peptido a la estructura
int len = strlen(peptideStr) - 8;
strcpy(peptides[r].string, peptideStr);
//printf("peptido: %s\n", peptides[r].string);
//Copiar afinidad
peptides[r].affinity = atof(affinity);
//printf("afinidad: %f\n", peptides[r].affinity);
//Crear lista de Cores
//Cores Longitud - 9 + 1
peptides[r].coreN = len;
Core *c = GetCores(peptideStr, fileNameBlosum, len, sizeEncode);
peptides[r].core = c;
r++;
}
}
}
comma = 0;
i = 0;
}
}
fclose(dataFile);
return peptides;
}
unsigned int CountRows(char *fileNameDB, char **alleles)
{
FILE *dataFile;
unsigned int nrows = 0, comma = 0, i = 0;
char c;
char cad[256];
char peptideStr[256];
int nAlleles = 1;//sizeof(alleles) / sizeof(alleles[0]);
dataFile = fopen(fileNameDB, "r");
while (!feof(dataFile))
{
c = fgetc(dataFile);
//Leer primera columna
if (comma == 0 && c != ',')
{
peptideStr[i] = c;
i++;
}
if (comma == 2 && c != '\n')
{
cad[i] = c;
i++;
}
if (c == ',')
{
if (comma == 0)
peptideStr[i] = '\0';
comma++;
i = 0;
}
if (c == '\n')
{
cad[i] = '\0';
int j;
for (j = 0; j < nAlleles; j++)
{
if (strcmp(alleles[j], cad) == 0)
{
//Si la longitud del péptido es mayor o igual a 9 es candidato a entrenar la RNA
if (strlen(peptideStr) >= 9){
//printf("%s\n", peptideStr);
nrows++;
}
}
}
i = 0;
comma = 0;
}
}
nrows--;
fclose(dataFile);
return nrows;
}
Revise this Paste