scalar_const_template.in

/* -*- mode: go; -*-
 *
 * Copyright (C) 2015-2020 Philipp Benner
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "macros.h"

/* -------------------------------------------------------------------------- */

package autodiff

/* -------------------------------------------------------------------------- */

import "fmt"
import "encoding/json"
import "math"
import "reflect"

/* -------------------------------------------------------------------------- */

type SCALAR_NAME SCALAR_TYPE

/* register scalar type
 * -------------------------------------------------------------------------- */

var SCALAR_REFLECT_TYPE ScalarType = NEW_SCALAR(0.0).Type()

func init() {
  f := func(value float64) ConstScalar { return NEW_SCALAR(SCALAR_TYPE(value)) }
  RegisterConstScalar(SCALAR_REFLECT_TYPE, f)
}

/* constructors
 * -------------------------------------------------------------------------- */

func NEW_SCALAR(v SCALAR_TYPE) SCALAR_NAME {
  return SCALAR_NAME(v)
}

func NULL_SCALAR() SCALAR_NAME {
  return SCALAR_NAME(0.0)
}

/* -------------------------------------------------------------------------- */

func (a SCALAR_NAME) Clone() SCALAR_NAME {
  return SCALAR_NAME(a)
}

func (a SCALAR_NAME) CloneConstScalar() ConstScalar {
  return a.Clone()
}

/* -------------------------------------------------------------------------- */

func (a SCALAR_NAME) Type() ScalarType {
  return reflect.TypeOf(a)
}

/* type conversion
 * -------------------------------------------------------------------------- */

func (a SCALAR_NAME) ConvertConstScalar(t ScalarType) ConstScalar {
  switch t {
  case SCALAR_REFLECT_TYPE:
    return a
  default:
    return NewConstScalar(t, a.GetFloat64())
  }
}

/* stringer
 * -------------------------------------------------------------------------- */

func (a  SCALAR_NAME) String() string {
  return fmt.Sprintf("%v", a.GET_METHOD_NAME())
}

/* read access
 * -------------------------------------------------------------------------- */

func (a SCALAR_NAME) GetInt8() int8 {
  return int8(a)
}

func (a SCALAR_NAME) GetInt16() int16 {
  return int16(a)
}

func (a SCALAR_NAME) GetInt32() int32 {
  return int32(a)
}

func (a SCALAR_NAME) GetInt64() int64 {
  return int64(a)
}

func (a SCALAR_NAME) GetInt() int {
  return int(a)
}

func (a SCALAR_NAME) GetFloat32() float32 {
  return float32(a)
}

func (a SCALAR_NAME) GetFloat64() float64 {
  return float64(a)
}

func (a  SCALAR_NAME) GetOrder() int {
  return 0
}

func (a  SCALAR_NAME) GetDerivative(i int) float64 {
  return 0.0
}

func (a  SCALAR_NAME) GetHessian(i, j int) float64 {
  return 0.0
}

func (a  SCALAR_NAME) GetN() int {
  return 0
}

/* json
 * -------------------------------------------------------------------------- */

func (obj  SCALAR_NAME) MarshalJSON() ([]byte, error) {
  return json.Marshal(obj)
}

/* math
 * -------------------------------------------------------------------------- */

func (a SCALAR_NAME) Equals(b ConstScalar, epsilon float64) bool {
#if SCALAR_TYPE == float32 || SCALAR_TYPE == float64
  v1 := a.GetFloat64()
  v2 := b.GetFloat64()
  return math.Abs(v1 - v2) < epsilon               ||
        (math.IsNaN(v1)     && math.IsNaN(v2))     ||
        (math.IsInf(v1,  1) && math.IsInf(v2,  1)) ||
        (math.IsInf(v1, -1) && math.IsInf(v2, -1))
#else
  return a.GET_METHOD_NAME() == b.GET_METHOD_NAME()
#endif
}

/* -------------------------------------------------------------------------- */

func (a SCALAR_NAME) Greater(b ConstScalar) bool {
  return a.GET_METHOD_NAME() > b.GET_METHOD_NAME()
}

/* -------------------------------------------------------------------------- */

func (a SCALAR_NAME) Smaller(b ConstScalar) bool {
  return a.GET_METHOD_NAME() < b.GET_METHOD_NAME()
}

/* -------------------------------------------------------------------------- */

func (a SCALAR_NAME) Sign() int {
  if a.GET_METHOD_NAME() < SCALAR_TYPE(0) {
    return -1
  }
  if a.GET_METHOD_NAME() > SCALAR_TYPE(0) {
    return  1
  }
  return 0
}