Diff


SUBMITTED BY: Guest

DATE: Jan. 11, 2017, 10:24 p.m.

FORMAT: C

SIZE: 3.6 kB

HITS: 985

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4. typedef struct values_s
  5. {
  6. double *x;
  7. double *funcval ;
  8. double *derivate ;
  9. long size ;
  10. } values_t ;
  11. values_t * values_allocate (long size )
  12. {
  13. values_t *elem;
  14. if(!(elem=calloc(1,sizeof(values_t))))
  15. {
  16. fprintf(stderr,"Fehler bei Speicherallozierung!\n");
  17. return 0;
  18. }
  19. elem->size=size;
  20. if(!(elem->x=calloc(size,sizeof(double))))
  21. {
  22. fprintf(stderr,"Fehler bei Speicherallozierung!\n");
  23. free(elem);
  24. return 0;
  25. }
  26. if(!(elem->funcval=calloc(size,sizeof(double))))
  27. {
  28. fprintf(stderr,"Fehler bei Speicherallozierung!\n");
  29. free(elem->x);
  30. free(elem);
  31. return 0;
  32. }
  33. if(!(elem->derivate=calloc(size,sizeof(double))))
  34. {
  35. fprintf(stderr,"Fehler bei Speicherallozierung!\n");
  36. free(elem->x);
  37. free(elem->funcval);
  38. free(elem);
  39. return 0;
  40. }
  41. return elem;
  42. }
  43. typedef enum boolean_e
  44. {
  45. FALSE = 0,
  46. TRUE = 1
  47. } boolean_t ;
  48. boolean_t values_insert ( values_t *val , double x1 , double x2 , double x3 , long index )
  49. {
  50. if(val==0||index<0||index>=val->size)
  51. return FALSE;
  52. val->x[index]=x1;
  53. val->funcval[index]=x2;
  54. val->derivate[index]=x3;
  55. return TRUE;
  56. }
  57. boolean_t values_free ( values_t *val)
  58. {
  59. if(val==0)
  60. return FALSE;
  61. free(val->derivate);
  62. val->derivate=0;
  63. free(val->funcval);
  64. val->funcval=0;
  65. free(val->x);
  66. val->x=0;
  67. free(val);
  68. return TRUE;
  69. }
  70. boolean_t values_print ( values_t *val)
  71. {
  72. if(val==0)
  73. return FALSE;
  74. long i;
  75. for(i=0;i<val->size;i++)
  76. printf("%3ld: %10g | %10g %10g\n",i,val->x[i],val->funcval[i],val->derivate[i]);
  77. return TRUE;
  78. }
  79. double function1(double x)
  80. {
  81. return pow(x,4)+6*pow(x,2)-1;
  82. }
  83. double function2(double x)
  84. {
  85. return cos(x);
  86. }
  87. double function3(double x)
  88. {
  89. return exp(pow(x,2));
  90. }
  91. double function4(double x)
  92. {
  93. return sqrt(pow(x,2)+3);
  94. }
  95. typedef double (*func_t)(double);
  96. boolean_t differentiate ( values_t *val , func_t func )
  97. {
  98. if(val==0)
  99. return FALSE;
  100. long i;
  101. for(i=0;i<val->size;i++)
  102. val->funcval[i]=func(val->x[i]);
  103. for(i=0;i<val->size;i++)
  104. {
  105. if(!(val->x[i+1]-val->x[i-1]))
  106. {
  107. fprintf(stderr,"Division durch 0!\n");
  108. return FALSE;
  109. }
  110. val->derivate[i]=(val->funcval[i+1]-val->funcval[i-1])/(val->x[i+1]-val->x[i-1]);
  111. }
  112. return TRUE;
  113. }
  114. boolean_t values_save ( values_t *val , char *file )
  115. {
  116. if(val==0)
  117. return FALSE;
  118. FILE *f;
  119. if(!(f=fopen(file,"w")))
  120. return FALSE;
  121. long i;
  122. for(i=0;i<val->size;i++)
  123. fprintf(f,"%3ld: %10g | %10g %10g\n",i,val->x[i],val->funcval[i],val->derivate[i]);
  124. fclose(f);
  125. return TRUE;
  126. }
  127. double function5(double x)
  128. {
  129. return atan(x)*x;
  130. }
  131. int main()
  132. {
  133. printf("Nummerisches Differenzieren!\n");
  134. values_t *elem=values_allocate(20);
  135. //double x=3;
  136. long i;
  137. double ug=0,og=5;
  138. double dx=(og-ug)/elem->size;
  139. for(i=0;i<elem->size;i++,ug+=dx)
  140. values_insert(elem,ug,0,0,i);//hier habe ich verändert
  141. differentiate(elem,function1);
  142. values_print(elem);
  143. if(values_save(elem,"test.txt")!=TRUE)
  144. fprintf(stderr,"Fehler beim Speichern!\n");
  145. if(values_free(elem)!=TRUE)
  146. {
  147. fprintf(stderr,"Fehler bei Speicherfreigabe!\n");
  148. exit(-1);
  149. }
  150. elem=0;
  151. return 0;
  152. }

comments powered by Disqus