#===============================================================================
# Copyright 2014 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#===============================================================================

import unittest
import numpy as np
import daal4py as d4p

dv = d4p._get__daal_link_version__
daal_version = tuple(map(int, (dv()[0:4], dv()[4:8])))


class Test(unittest.TestCase):
    def test_non_contig(self):
        from numpy.random import rand
        p = 10007
        nx = 1017
        ny = 77
        X = rand(p + 1, nx + 1)
        Xp = rand(p + 1, nx + 1)
        y = rand(p + 1, ny + 1)
        Xn = X[:p, :nx]
        Xpn = Xp[:p, :nx]
        yn = y[:p, :ny]
        Xc = np.ascontiguousarray(Xn)
        Xpc = np.ascontiguousarray(Xpn)
        yc = np.ascontiguousarray(yn)
        self.assertTrue(all([not Xn.flags['C_CONTIGUOUS'],
                             not Xpn.flags['C_CONTIGUOUS'],
                             not yn.flags['C_CONTIGUOUS']]))
        self.assertTrue(all([Xc.flags['C_CONTIGUOUS'],
                             Xpc.flags['C_CONTIGUOUS'],
                             yc.flags['C_CONTIGUOUS']]))
        self.assertTrue(all([np.allclose(Xc, Xn),
                             np.allclose(Xpc, Xpn),
                             np.allclose(yc, yn)]))
        regr_train = d4p.linear_regression_training()
        rtc = regr_train.compute(Xc, yc)
        regr_predict = d4p.linear_regression_prediction()
        rpc = regr_predict.compute(Xpc, rtc.model)
        regr_train = d4p.linear_regression_training()
        rtn = regr_train.compute(Xn, yn)
        regr_predict = d4p.linear_regression_prediction()
        rpn = regr_predict.compute(Xpn, rtn.model)
        self.assertTrue(np.allclose(rpn.prediction, rpc.prediction))

    def test_struct(self):
        sdata = np.array([(0.5, -1.3, 1, 100.11, 1111111),
                          (2.5, -3.3, 2, 200.22, 2222222),
                          (4.5, -5.3, 2, 350.33, 3333333),
                          (6.5, -7.3, 0, 470.44, 4444444),
                          (8.5, -9.3, 1, 270.55, 55555)],
                         dtype=[('x', 'f4'),
                                ('y', 'f4'),
                                ('categ', 'i4'),
                                ('value', 'f8'),
                                ('super', 'i8')])
        hdata = np.array([(0.5, -1.3, 1, 100.11, 1111111),
                          (2.5, -3.3, 2, 200.22, 2222222),
                          (4.5, -5.3, 2, 350.33, 3333333),
                          (6.5, -7.3, 0, 470.44, 4444444),
                          (8.5, -9.3, 1, 270.55, 55555)],
                         dtype=np.float64)
        sr = d4p.cosine_distance().compute(sdata)
        hr = d4p.cosine_distance().compute(hdata)
        self.assertTrue(np.allclose(hr.cosineDistance, sr.cosineDistance))


if __name__ == '__main__':
    unittest.main()
