zsolve/vectorarray.c

   1 /*
   2 4ti2 -- A software package for algebraic, geometric and combinatorial
   3 problems on linear spaces.
   4
   5 Copyright (C) 2006 4ti2 team.
   6 Main author(s): Matthias Walter.
   7
   8 This program is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU General Public License
  10 as published by the Free Software Foundation; either version 2
  11 of the License, or (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21 */
  22
  23 #include "vectorarray.h"
  24
  25 #include <assert.h>
  26 #include <stdlib.h>
  27
  28 //                                                                            //
  29
  30 VectorArray createVectorArray(int var)
  31 {
  32         VectorArray array = (VectorArray)malloc(sizeof(vectorarray_t));
  33
  34         if (array==NULL)
  35         {
  36                 fprintf(stderr, "Fatal Error (%s/%d): Could not allocate memory for VectorArray!\n", __FILE__, __LINE__);
  37                 exit(1);
  38         }
  39
  40         array->Variables = var;
  41         array->Memory = 0;
  42         array->Size = 0;
  43         array->Data = NULL;
  44         array->Properties = createVariableProperties(var);
  45
  46         return array;
  47 }
  48
  49 //                                                                            //
  50
  51 void deleteVectorArray(VectorArray array)
  52 {
  53         int i;
  54
  55         if (array)
  56         {
  57                 for (i=0; i<array->Size; i++)
  58                         deleteVector(array->Data[i]);
  59
  60                 deleteVariableProperties(array->Properties);
  61
  62                 free(array->Data);
  63                 free(array);
  64         }
  65 }
  66
  67 //                                                                            //
  68
  69 void fprintVectorArray(FILE *stream, VectorArray array, bool header)
  70 {
  71         int i;
  72
  73         assert(stream);
  74         assert(array);
  75
  76         if (header)
  77         {
  78                 fprintf(stream, "%d %d\n\n", array->Size, array->Variables);
  79                 fprintVariableProperties(stream, array->Properties, array->Variables);
  80                 fputs("\n", stream);
  81         }
  82
  83         for (i=0; i<array->Size; i++)
  84         {
  85                 fprintVector(stream, array->Data[i], array->Variables);
  86                 fputs("\n", stream);
  87         }
  88 }
  89
  90 //                                                                            //
  91
  92 inline void printVectorArray(VectorArray array, bool header)
  93 {
  94         assert(array);
  95
  96         fprintVectorArray(stdout, array, header);
  97 }
  98
  99 //                                                                            //
 100
 101 void appendToVectorArray(VectorArray array, Vector vector)
 102 {
 103         assert(array);
 104         assert(vector);
 105
 106         array->Size++;
 107         if (array->Size>array->Memory)
 108         {
 109                 array->Memory = 2*(array->Memory+1);
 110                 array->Data = (Vector *)realloc(array->Data, array->Memory * sizeof(Vector));
 111         }
 112         array->Data[array->Size-1] = vector;
 113 }
 114
 115 //                                                                            //
 116
 117 void swapVectorArrayRows(VectorArray array, int a, int b)
 118 {
 119         Vector vector;
 120
 121         assert(array);
 122         assert(a>=0 && a<array->Size);
 123         assert(b>=0 && b<array->Size);
 124
 125         vector = array->Data[a];
 126         array->Data[a] = array->Data[b];
 127         array->Data[b] = vector;
 128 }
 129
 130 //                                                                            //
 131
 132 void swapVectorArrayColumns(VectorArray array, int a, int b)
 133 {
 134         int i;
 135
 136         assert(array);
 137         assert(a>=0 && a<array->Variables);
 138         assert(b>=0 && b<array->Variables);
 139
 140         for (i=0; i<array->Size; i++)
 141                 swapVector(array->Data[i], a, b);
 142         swapVariableProperties(array->Properties, a, b);
 143 }
 144
 145 //                                                                            //
 146
 147 void appendVectorArrayNegatives(VectorArray array)
 148 {
 149         int i,j;
 150         Vector vec;
 151
 152         assert(array);
 153
 154         vec = createVector(array->Variables);
 155         for (i=array->Size-1; i>=0; i--)
 156         {
 157                 for (j=0; j<array->Variables; j++)
 158                         vec[j] = -array->Data[i][j];
 159                 appendToVectorArray(array, copyVector(vec, array->Variables));
 160         }
 161         deleteVector(vec);
 162 }
 163
 164 //                                                                            //
 165
 166 void sortVectorArrayColumns(VectorArray array, ColumnCompare cmp)
 167 {
 168         int i,j;
 169         int bestvalue, bestindex;
 170
 171         assert(array);
 172         assert(cmp);
 173
 174         for (i=0; i<array->Variables-1; i++)
 175         {
 176                 bestindex = i;
 177                 bestvalue = array->Properties[i].Column;
 178                 for (j=i+1; j<array->Variables; j++)
 179                 {
 180                         if (cmp(array->Properties[j].Column, bestvalue) < 0)
 181                         {
 182                                 bestindex = j;
 183                                 bestvalue = array->Properties[j].Column;
 184                         }
 185                 }
 186                 swapVectorArrayColumns(array, i, bestindex);
 187         }
 188 }
 189
 190 //                                                                            //
 191
 192 VectorArray readVectorArray(FILE *stream, bool header)
 193 {
 194         VectorArray array;
 195         Vector vector;
 196         int size, vars;
 197
 198         if (fscanf(stream, "%d %d", &size, &vars)!=2)
 199                 return NULL;
 200
 201         array = createVectorArray(vars);
 202
 203         if (header)
 204                 readVariableProperties(stream, array->Properties, vars);
 205
 206         while (size--)
 207         {
 208                 vector = readVector(stream, vars);
 209                 if (vector)
 210                         appendToVectorArray(array, vector);
 211                 else
 212                 {
 213                         deleteVectorArray(array);
 214                         return NULL;
 215                 }
 216         }
 217
 218         return array;
 219 }