{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Forecast.Types.ParameterRanges
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Forecast.Types.ParameterRanges where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Forecast.Types.CategoricalParameterRange
import Amazonka.Forecast.Types.ContinuousParameterRange
import Amazonka.Forecast.Types.IntegerParameterRange
import qualified Amazonka.Prelude as Prelude

-- | Specifies the categorical, continuous, and integer hyperparameters, and
-- their ranges of tunable values. The range of tunable values determines
-- which values that a hyperparameter tuning job can choose for the
-- specified hyperparameter. This object is part of the
-- HyperParameterTuningJobConfig object.
--
-- /See:/ 'newParameterRanges' smart constructor.
data ParameterRanges = ParameterRanges'
  { -- | Specifies the tunable range for each categorical hyperparameter.
    ParameterRanges -> Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges :: Prelude.Maybe (Prelude.NonEmpty CategoricalParameterRange),
    -- | Specifies the tunable range for each continuous hyperparameter.
    ParameterRanges -> Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges :: Prelude.Maybe (Prelude.NonEmpty ContinuousParameterRange),
    -- | Specifies the tunable range for each integer hyperparameter.
    ParameterRanges -> Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges :: Prelude.Maybe (Prelude.NonEmpty IntegerParameterRange)
  }
  deriving (ParameterRanges -> ParameterRanges -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParameterRanges -> ParameterRanges -> Bool
$c/= :: ParameterRanges -> ParameterRanges -> Bool
== :: ParameterRanges -> ParameterRanges -> Bool
$c== :: ParameterRanges -> ParameterRanges -> Bool
Prelude.Eq, ReadPrec [ParameterRanges]
ReadPrec ParameterRanges
Int -> ReadS ParameterRanges
ReadS [ParameterRanges]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ParameterRanges]
$creadListPrec :: ReadPrec [ParameterRanges]
readPrec :: ReadPrec ParameterRanges
$creadPrec :: ReadPrec ParameterRanges
readList :: ReadS [ParameterRanges]
$creadList :: ReadS [ParameterRanges]
readsPrec :: Int -> ReadS ParameterRanges
$creadsPrec :: Int -> ReadS ParameterRanges
Prelude.Read, Int -> ParameterRanges -> ShowS
[ParameterRanges] -> ShowS
ParameterRanges -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParameterRanges] -> ShowS
$cshowList :: [ParameterRanges] -> ShowS
show :: ParameterRanges -> String
$cshow :: ParameterRanges -> String
showsPrec :: Int -> ParameterRanges -> ShowS
$cshowsPrec :: Int -> ParameterRanges -> ShowS
Prelude.Show, forall x. Rep ParameterRanges x -> ParameterRanges
forall x. ParameterRanges -> Rep ParameterRanges x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ParameterRanges x -> ParameterRanges
$cfrom :: forall x. ParameterRanges -> Rep ParameterRanges x
Prelude.Generic)

-- |
-- Create a value of 'ParameterRanges' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'categoricalParameterRanges', 'parameterRanges_categoricalParameterRanges' - Specifies the tunable range for each categorical hyperparameter.
--
-- 'continuousParameterRanges', 'parameterRanges_continuousParameterRanges' - Specifies the tunable range for each continuous hyperparameter.
--
-- 'integerParameterRanges', 'parameterRanges_integerParameterRanges' - Specifies the tunable range for each integer hyperparameter.
newParameterRanges ::
  ParameterRanges
newParameterRanges :: ParameterRanges
newParameterRanges =
  ParameterRanges'
    { $sel:categoricalParameterRanges:ParameterRanges' :: Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges =
        forall a. Maybe a
Prelude.Nothing,
      $sel:continuousParameterRanges:ParameterRanges' :: Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges = forall a. Maybe a
Prelude.Nothing,
      $sel:integerParameterRanges:ParameterRanges' :: Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges = forall a. Maybe a
Prelude.Nothing
    }

-- | Specifies the tunable range for each categorical hyperparameter.
parameterRanges_categoricalParameterRanges :: Lens.Lens' ParameterRanges (Prelude.Maybe (Prelude.NonEmpty CategoricalParameterRange))
parameterRanges_categoricalParameterRanges :: Lens' ParameterRanges (Maybe (NonEmpty CategoricalParameterRange))
parameterRanges_categoricalParameterRanges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ParameterRanges' {Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges :: Maybe (NonEmpty CategoricalParameterRange)
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges} -> Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges) (\s :: ParameterRanges
s@ParameterRanges' {} Maybe (NonEmpty CategoricalParameterRange)
a -> ParameterRanges
s {$sel:categoricalParameterRanges:ParameterRanges' :: Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges = Maybe (NonEmpty CategoricalParameterRange)
a} :: ParameterRanges) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies the tunable range for each continuous hyperparameter.
parameterRanges_continuousParameterRanges :: Lens.Lens' ParameterRanges (Prelude.Maybe (Prelude.NonEmpty ContinuousParameterRange))
parameterRanges_continuousParameterRanges :: Lens' ParameterRanges (Maybe (NonEmpty ContinuousParameterRange))
parameterRanges_continuousParameterRanges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ParameterRanges' {Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges :: Maybe (NonEmpty ContinuousParameterRange)
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges} -> Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges) (\s :: ParameterRanges
s@ParameterRanges' {} Maybe (NonEmpty ContinuousParameterRange)
a -> ParameterRanges
s {$sel:continuousParameterRanges:ParameterRanges' :: Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges = Maybe (NonEmpty ContinuousParameterRange)
a} :: ParameterRanges) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies the tunable range for each integer hyperparameter.
parameterRanges_integerParameterRanges :: Lens.Lens' ParameterRanges (Prelude.Maybe (Prelude.NonEmpty IntegerParameterRange))
parameterRanges_integerParameterRanges :: Lens' ParameterRanges (Maybe (NonEmpty IntegerParameterRange))
parameterRanges_integerParameterRanges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ParameterRanges' {Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges :: Maybe (NonEmpty IntegerParameterRange)
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges} -> Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges) (\s :: ParameterRanges
s@ParameterRanges' {} Maybe (NonEmpty IntegerParameterRange)
a -> ParameterRanges
s {$sel:integerParameterRanges:ParameterRanges' :: Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges = Maybe (NonEmpty IntegerParameterRange)
a} :: ParameterRanges) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Data.FromJSON ParameterRanges where
  parseJSON :: Value -> Parser ParameterRanges
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"ParameterRanges"
      ( \Object
x ->
          Maybe (NonEmpty CategoricalParameterRange)
-> Maybe (NonEmpty ContinuousParameterRange)
-> Maybe (NonEmpty IntegerParameterRange)
-> ParameterRanges
ParameterRanges'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CategoricalParameterRanges")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ContinuousParameterRanges")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"IntegerParameterRanges")
      )

instance Prelude.Hashable ParameterRanges where
  hashWithSalt :: Int -> ParameterRanges -> Int
hashWithSalt Int
_salt ParameterRanges' {Maybe (NonEmpty CategoricalParameterRange)
Maybe (NonEmpty IntegerParameterRange)
Maybe (NonEmpty ContinuousParameterRange)
integerParameterRanges :: Maybe (NonEmpty IntegerParameterRange)
continuousParameterRanges :: Maybe (NonEmpty ContinuousParameterRange)
categoricalParameterRanges :: Maybe (NonEmpty CategoricalParameterRange)
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty IntegerParameterRange)
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty ContinuousParameterRange)
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty CategoricalParameterRange)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges

instance Prelude.NFData ParameterRanges where
  rnf :: ParameterRanges -> ()
rnf ParameterRanges' {Maybe (NonEmpty CategoricalParameterRange)
Maybe (NonEmpty IntegerParameterRange)
Maybe (NonEmpty ContinuousParameterRange)
integerParameterRanges :: Maybe (NonEmpty IntegerParameterRange)
continuousParameterRanges :: Maybe (NonEmpty ContinuousParameterRange)
categoricalParameterRanges :: Maybe (NonEmpty CategoricalParameterRange)
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty IntegerParameterRange)
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty ContinuousParameterRange)
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty CategoricalParameterRange)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges

instance Data.ToJSON ParameterRanges where
  toJSON :: ParameterRanges -> Value
toJSON ParameterRanges' {Maybe (NonEmpty CategoricalParameterRange)
Maybe (NonEmpty IntegerParameterRange)
Maybe (NonEmpty ContinuousParameterRange)
integerParameterRanges :: Maybe (NonEmpty IntegerParameterRange)
continuousParameterRanges :: Maybe (NonEmpty ContinuousParameterRange)
categoricalParameterRanges :: Maybe (NonEmpty CategoricalParameterRange)
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty IntegerParameterRange)
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty ContinuousParameterRange)
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe (NonEmpty CategoricalParameterRange)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CategoricalParameterRanges" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty CategoricalParameterRange)
categoricalParameterRanges,
            (Key
"ContinuousParameterRanges" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty ContinuousParameterRange)
continuousParameterRanges,
            (Key
"IntegerParameterRanges" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty IntegerParameterRange)
integerParameterRanges
          ]
      )