hkl/hkl-unit.c

   1 /* This file is part of the hkl library.
   2  *
   3  * The hkl library is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * The hkl library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with the hkl library.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright (C) 2003-2011 Synchrotron SOLEIL
  17  *                         L'Orme des Merisiers Saint-Aubin
  18  *                         BP 48 91192 GIF-sur-YVETTE CEDEX
  19  *
  20  * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
  21  */
  22 #include <math.h>
  23 #include <gsl/gsl_nan.h>
  24 #include <gsl/gsl_sys.h> /* gsl_nan()! */
  25 #include <hkl/hkl-unit.h>
  26
  27 /**
  28  * hkl_unit_dup: (skip)
  29  * @self:
  30  *
  31  * copy an #Hklunit
  32  *
  33  * Returns: the copied #HklUnit (memory must be release with
  34  * hkl_unit_free)
  35  **/
  36 HklUnit* hkl_unit_dup(const HklUnit *self)
  37 {
  38         if (!self)
  39                 return NULL;
  40
  41         HklUnit *dup = HKL_MALLOC(HklUnit);
  42         *dup = *self;
  43
  44         return dup;
  45 }
  46
  47 /**
  48  * hkl_unit_free: (skip)
  49  * @self:
  50  *
  51  * release the memory of an #HklUnit
  52  **/
  53 void hkl_unit_free(HklUnit *self)
  54 {
  55         if (self)
  56                 free(self);
  57 }
  58
  59 /**
  60  * hkl_unit_compatible: check if two units are compatible.
  61  * @self: the first @HklUnit
  62  * @unit: the second @HklUnit to check
  63  *
  64  * Returns: HKL_TRUE or HKL_FALSE
  65  **/
  66 int hkl_unit_compatible(const HklUnit *self, const HklUnit *unit)
  67 {
  68         int res = HKL_TRUE;
  69         if (self && unit){
  70                 switch(self->type){
  71                 case HKL_UNIT_ANGLE_DEG:
  72                         switch(unit->type){
  73                         case HKL_UNIT_ANGLE_DEG:
  74                         case HKL_UNIT_ANGLE_RAD:
  75                                 break;
  76                         default:
  77                                 res = HKL_FALSE;
  78                                 break;
  79                         }
  80                         break;
  81                 case HKL_UNIT_ANGLE_RAD:
  82                         switch(unit->type){
  83                         case HKL_UNIT_ANGLE_DEG:
  84                         case HKL_UNIT_ANGLE_RAD:
  85                                 break;
  86                         default:
  87                                 res = HKL_FALSE;
  88                                 break;
  89                         }
  90                         break;
  91                 case HKL_UNIT_LENGTH_NM:
  92                         switch(unit->type){
  93                         case HKL_UNIT_LENGTH_NM:
  94                                 break;
  95                         default:
  96                                 res = HKL_FALSE;
  97                                 break;
  98                         }
  99                 }
 100         }
 101         return res;
 102 }
 103
 104 /**
 105  * hkl_unit_factor:
 106  * @self:
 107  * @unit:
 108  *
 109  * compute the factor to convert from one @Hklunit to another one.
 110  * @self * factor =  @unit
 111  *
 112  * Returns: the factor of the conversion.
 113  **/
 114 double hkl_unit_factor(const HklUnit *self, const HklUnit *unit)
 115 {
 116         double factor = 1.;
 117
 118         if (self && unit){
 119                 switch(self->type){
 120                 case HKL_UNIT_ANGLE_DEG:
 121                         switch(unit->type){
 122                         case HKL_UNIT_ANGLE_DEG:
 123                                 break;
 124                         case HKL_UNIT_ANGLE_RAD:
 125                                 factor = HKL_DEGTORAD;
 126                                 break;
 127                         default:
 128                                 factor = GSL_NAN;
 129                                 break;
 130                         }
 131                         break;
 132                 case HKL_UNIT_ANGLE_RAD:
 133                         switch(unit->type){
 134                         case HKL_UNIT_ANGLE_DEG:
 135                                 factor = HKL_RADTODEG;
 136                                 break;
 137                         case HKL_UNIT_ANGLE_RAD:
 138                                 break;
 139                         default:
 140                                 factor = GSL_NAN;
 141                                 break;
 142                         }
 143                         break;
 144                 case HKL_UNIT_LENGTH_NM:
 145                         switch(unit->type){
 146                         case HKL_UNIT_LENGTH_NM:
 147                                 break;
 148                         default:
 149                                 factor = GSL_NAN;
 150                                 break;
 151                         }
 152                 }
 153         }
 154         return factor;
 155 }