def write_ppc_file(fname):
    """Save PYPOWER file. 
    """
    
    filename = fname
        
    base = os.path.basename(fname)
    casename = os.path.splitext(base)[0]
    
    outfile = open(fname, 'w', newline='')
    
    outfile.write('from numpy import array\n\n')
    
    outfile.write('def ' + casename + '():\n') 
    outfile.write('\tppc = {"version": ''2''}\n')
    outfile.write('\tppc["baseMVA"] = 100.0\n')
   
    outfile.write('\tppc["bus"] = ')
    outfile.write(np.array_repr(ppc["bus"]))
    outfile.write('\n\n')
     
    outfile.write('\tppc["gen"] = ')
    outfile.write(np.array_repr(ppc["gen"]))
    outfile.write('\n\n')
    
    outfile.write('\tppc["branch"] = ')
    outfile.write(np.array_repr(ppc["branch"]))
    outfile.write('\n\n')
    
    outfile.write('\treturn ppc')
    outfile.close()
    
    return True

 def __repr__(self):
   # if numpy.all(self == 0):
   #   # Bin-only output
   #   return "{}(bins={})".format(type(self).__name__, numpy.array_repr(self._bins))
   # else:
   if self.ndim == 1:
     return "{}({}, data={})".format(type(self).__name__,
       numpy.array_repr(self._bins)[len("array("):-1], 
       numpy.array_repr(self)[len(type(self).__name__)+1:-1])
   else:
     return "{}(({}), data={})".format(type(self).__name__,
       ",".join([numpy.array_repr(x)[6:-1] for x in self._bins]), 
       numpy.array_repr(self)[len(type(self).__name__)+1:-1])

def test():
    from sklearn.metrics import mean_squared_error
    import Surrogates.DataExtraction.pcs_parser as pcs_parser
    sp = pcs_parser.read(file("/home/eggenspk/Surrogates/Data_extraction/Experiments2014/hpnnet/smac_2_06_01-dev/nips2011.pcs"))
    # Read data from csv
    header, data = read_csv("/home/eggenspk/Surrogates/Data_extraction/hpnnet_nocv_convex_all/hpnnet_nocv_convex_all_fastrf_results.csv",
                            has_header=True, num_header_rows=3)
    para_header = header[0][:-2]
    type_header = header[1]
    cond_header = header[2]
    #print data.shape
    checkpoint = hash(numpy.array_repr(data))
    assert checkpoint == 246450380584980815

    model = GaussianProcess(sp=sp, encode=False, rng=1, debug=True)
    x_train_data = data[:100, :-2]
    y_train_data = data[:100, -1]
    x_test_data = data[100:, :-2]
    y_test_data = data[100:, -1]

    model.train(x=x_train_data, y=y_train_data, param_names=para_header)

    y = model.predict(x=x_train_data[1, :])
    print "Is: %100.70f, Should: %f" % (y, y_train_data[1])
    assert y[0] == 0.470745153514900149804844886602950282394886016845703125

    print "Predict whole data"
    y_whole = model.predict(x=x_test_data)
    mse = mean_squared_error(y_true=y_test_data, y_pred=y_whole)
    print "MSE: %100.70f" % mse
    assert mse == 0.006257598609004190459703664828339242376387119293212890625

    print "Soweit so gut"

    # Try the same with encoded features
    model = GaussianProcess(sp=sp, encode=True, rng=1, debug=True)
    #print data[:10, :-2]
    model.train(x=x_train_data, y=y_train_data, param_names=para_header)

    y = model.predict(x=x_train_data[1, :])
    print "Is: %100.70f, Should: %f" % (y, y_train_data[1])
    assert y[0] == 0.464671665294324409689608046392095275223255157470703125

    print "Predict whole data"
    y_whole = model.predict(x=x_test_data)
    mse = mean_squared_error(y_true=y_test_data, y_pred=y_whole)
    print "MSE: %100.70f" % mse
    assert mse == 0.00919265128042330570412588031103950925171375274658203125

    assert hash(numpy.array_repr(data)) == checkpoint

def myf(x):
	header = 'MaxStepX, TorsoWy, TorsoWx, StepHeight, Stiffness, MaxStepTheta, MaxStepY, MaxStepFrequency'
	print header
	print np.array_repr(x[0]).replace('\n', '').replace('\t', '')
	speed = input('Input 1/average_speed = ')
	output = np.array(float(speed))

	with open("data_new.py",'a') as f:
		np.savetxt(f, x, delimiter=",")
	# 	for item in x:
	# 		f.write("%s\n" % str(np.array_repr(item).replace('\n', '').replace('\t', '')))
	with open("readings_new.py",'a') as f:
		f.write("%s\n" % str(output))
	return output

def test():
    from sklearn.metrics import mean_squared_error
    import Surrogates.DataExtraction.pcs_parser as pcs_parser
    sp = pcs_parser.read(file("/home/eggenspk/Surrogates/Data_extraction/Experiments2014/hpnnet/smac_2_06_01-dev/nips2011.pcs"))
    # Read data from csv
    header, data = read_csv("/home/eggenspk/Surrogates/Data_extraction/hpnnet_nocv_convex_all/hpnnet_nocv_convex_all_fastrf_results.csv",
                            has_header=True, num_header_rows=3)
    para_header = header[0][:-2]
    type_header = header[1]
    cond_header = header[2]
    #print data.shape
    checkpoint = hash(numpy.array_repr(data))
    assert checkpoint == 246450380584980815

    model = GradientBoosting(sp=sp, encode=False, debug=True)
    x_train_data = data[:1000, :-2]
    y_train_data = data[:1000, -1]
    x_test_data = data[1000:, :-2]
    y_test_data = data[1000:, -1]

    model.train(x=x_train_data, y=y_train_data, param_names=para_header, rng=1)

    y = model.predict(x=x_train_data[1, :])
    print "Is: %100.70f, Should: %f" % (y, y_train_data[1])
    assert y[0] == 0.45366000254662230961599789225147105753421783447265625

    print "Predict whole data"
    y_whole = model.predict(x=x_test_data)
    mse = mean_squared_error(y_true=y_test_data, y_pred=y_whole)
    print "MSE: %100.70f" % mse
    assert mse == 0.00188246958253847243396073007914992558653466403484344482421875

    print "Soweit so gut"

    # Try the same with encoded features
    model = GradientBoosting(sp=sp, encode=True, debug=True)
    #print data[:10, :-2]
    model.train(x=x_train_data, y=y_train_data, param_names=para_header, rng=1)

    y = model.predict(x=x_train_data[1, :])
    print "Is: %100.70f, Should: %f" % (y, y_train_data[1])
    assert y[0] == 0.460818965082699205648708584703854285180568695068359375

    print "Predict whole data"
    y_whole = model.predict(x=x_test_data)
    mse = mean_squared_error(y_true=y_test_data, y_pred=y_whole)
    print "MSE: %100.70f" % mse
    assert mse == 0.002064362783199560034963493393433964229188859462738037109375

    assert hash(numpy.array_repr(data)) == checkpoint

    def showProjectionDialog(self):
        """Get and set OpenGL ModelView matrix and focus.
        Useful for setting two different instances to the exact same projection"""
        dlg = uic.loadUi("multilineinputdialog.ui")
        dlg.setWindowTitle("Get and set OpenGL ModelView matrix and focus")
        precision = 8  # use default precision
        MV_repr = np.array_repr(self.MV, precision=precision)
        focus_repr = np.array_repr(self.focus, precision=precision)
        txt = "self.MV = \\\n" "%s\n\n" "self.focus = %s" % (MV_repr, focus_repr)
        dlg.plainTextEdit.insertPlainText(txt)
        dlg.plainTextEdit.selectAll()
        if dlg.exec_():  # returns 1 if OK, 0 if Cancel
            txt = str(dlg.plainTextEdit.toPlainText())
            from numpy import array, float32  # required for exec()

            exec(txt)  # update self.MV and self.focus, with hopefully no maliciousness

 def setUp(self):
     self._sp = pcs_parser.read(file(os.path.join(os.path.dirname(os.path.realpath(__file__)), "Testdata/nips2011.pcs")))
     # Read data from csv
     header, self._data = read_csv(os.path.join(os.path.dirname(os.path.realpath(__file__)), "Testdata/hpnnet_nocv_convex_all_fastrf_results.csv"),
                                   has_header=True, num_header_rows=3)
     self._para_header = header[0][:-2]
     self._checkpoint = hash(numpy.array_repr(self._data))

  def __init__(self,q,x,f,qdesc="q",xdesc="x",fdesc="f"):
    """
    q    ... 1D-array of shape (q.size)
    x    ... 2D-array of shape (q.size,x.size)
    f    ... 2D-array of shape (q.size,x.size)
    *desc... description string for q,x,f
    """
    
    self.f = np.asarray(f,dtype='float');
    self.x = np.asarray(x,dtype='float');
    self.q = np.asarray(q,dtype='float');
    self.fdesc = fdesc;
    self.xdesc = xdesc;
    self.qdesc = qdesc;

    # complete input data (if constant for different q)
    if (len(self.x.shape)==1):
      self.x=np.tile(self.x,(len(self.q),1));
    if (len(self.f.shape)==1):
      self.f=np.tile(self.f,(len(self.q),1));

    # test shape of input data
    if (self.q.shape[0] <> self.x.shape[0]) or \
       (self.x.shape    <> self.f.shape):
      raise ValueError("Invalid shape of arguments.");

    # test for double parameters
    if (np.unique(self.q).size < self.q.size):
      raise ValueError("Parameters are not unique: \n " + np.array_repr(np.sort(self.q)));

    def write(self):
        outdict = {'model'            : self.model,
                   'data_out'         : {'q'       : json.dumps(self.q_vals_out),
                                         'i'       : json.dumps(self.i_vals_out),
                                         'units'   : 'A^-1'},
                   'run'              : {'command' : self.command,
                                         'date'    : str(datetime.date.today()),
                                         'time'    : str(datetime.time())},
                   'parameters_in'    : self.parameters_in}

        if self.dataset:
            outdict['dataset'] = {'q_in' : json.dumps(self.datain.q),
                                  'i_in' : json.dumps(self.datain.i)}
            
        if (self.fitsuccess and (self.command == 'fit')):
            outdict['fit'] = {'chi^2'          : self.chisqr,
                              'cov_x'          : np.array_repr(self.cov_x),
                              'parameters_out' : self.parameters}

        path, filename = os.path.split(self.outpath)
        if filename == '':
             filename = self.outfile
             
        if not os.path.exists(path):
            os.mkdir(path)

        if self.xml:
            self.write_cml(path, filename)

        else:
            f = open(os.path.join(path, filename), 'w')
            json.dump(outdict, f)
            f.close()

    def __repr__(self):
        """representation a mdf_skeleton class data strucutre

        Returns:
        ------------
        string of mdf class ordered as below
        master_channel_name
            channel_name   description
            numpy_array    unit
        """
        output = 'file name : ' + self.fileName + '\n'
        for m in self.file_metadata.keys():
            output += m + ' : ' + str(self.file_metadata[m]) + '\n'
        output += '\nchannels listed by data groups:\n'
        for d in self.masterChannelList.keys():
            if d is not None:
                output += d + '\n'
            for c in self.masterChannelList[d]:
                output += '  ' + c + ' : '
                desc = self.getChannelDesc(c)
                if desc is not None:
                    output += str(desc)
                output += '\n    '
                data = self.getChannelData(c)
                if data.dtype.kind != 'V': # not byte, impossible to represent
                    output += array_repr(data, \
                        precision=3, suppress_small=True)
                unit = self.getChannelUnit(c)
                output += ' ' + unit + '\n'
        return output

    def test_train(self):
        model = Surrogates.RegressionModels.RidgeRegression.RidgeRegression(sp=self._sp, encode=False, rng=1, debug=True)
        x_train_data = self._data[:1000, :-2]
        y_train_data = self._data[:1000, -1]
        x_test_data = self._data[1000:, :-2]
        y_test_data = self._data[1000:, -1]

        self.assertEqual(hash(numpy.array_repr(x_train_data)), -4233919799601849470)
        self.assertEqual(hash(numpy.array_repr(y_train_data)), -5203961977442829493)

        model.train(x=x_train_data, y=y_train_data, param_names=self._para_header)

        lower, upper = model._scale_info
        should_be_lower = [None, -29.6210089736, 0.201346561323, 0, -20.6929600285, 0, 0, 0, 4.60517018599, 0,
                           2.77258872224, 0, 0, 0.502038871605, -17.2269829469]
        should_be_upper = [None, -7.33342451433, 1.99996215592, 1, -6.92778489957, 2, 1, 1, 9.20883924585, 1,
                           6.9314718056, 3, 1, 0.998243871085, 4.72337617503]

        for idx in range(x_train_data.shape[1]):
            self.assertEqual(lower[idx], should_be_lower[idx])
            self.assertEqual(upper[idx], should_be_upper[idx])

        y = model.predict(x=x_train_data[1, :])
        print "Is: %100.70f, Should: %f" % (y, y_train_data[1])
        self.assertAlmostEqual(y[0], 0.337919078549359763741222195676527917385101318359375, msg=y[0])

        print "Predict whole data"
        y_whole = model.predict(x=x_test_data)
        mse = mean_squared_error(y_true=y_test_data, y_pred=y_whole)
        print "MSE: %100.70f" % mse
        self.assertAlmostEqual(mse, 0.009198484147153261625273756862)

        # Try the same with encoded features
        model = Surrogates.RegressionModels.RidgeRegression.RidgeRegression(sp=self._sp, encode=True, rng=1, debug=True)
        #print data[:10, :-2]
        model.train(x=x_train_data, y=y_train_data, param_names=self._para_header, rng=1)

        y = model.predict(x=self._data[1, :-2])
        print "Is: %100.70f, Should: %f" % (y, self._data[1, -2])
        self.assertAlmostEqual(y[0], 0.337619548171, msg="%f" % y[0])

        print "Predict whole data"
        y_whole = model.predict(x=x_test_data)
        mse = mean_squared_error(y_true=y_test_data, y_pred=y_whole)
        print "MSE: %100.70f" % mse
        self.assertAlmostEqual(mse, 0.0092026737874672301)

 def __str__(self):
     """ prints compressed_data object content
     """
     output = 'Data: \n'
     output += array_repr(self.data[:],
                          precision=3,
                          suppress_small=True)
     output += '\n Compression level ' + str(self._compression_level) + '\n'
     return output

    def _repr_footer(self):
        levheader = "Levels (%d): " % len(self.levels)
        # TODO: should max_line_width respect a setting?
        levstring = np.array_repr(self.levels, max_line_width=60)
        indent = " " * (levstring.find("[") + len(levheader) + 1)
        lines = levstring.split("\n")
        levstring = "\n".join([lines[0]] + [indent + x.lstrip() for x in lines[1:]])

        namestr = "Name: %s, " % self.name if self.name is not None else ""
        return u("%s\n%sLength: %d" % (levheader + levstring, namestr, len(self)))

    def __repr__(self):
        temp = "Categorical: %s\n%s\n%s"
        values = np.asarray(self)
        levheader = "Levels (%d): " % len(self.levels)
        levstring = np.array_repr(self.levels, max_line_width=60)

        indent = " " * (levstring.find("[") + len(levheader) + 1)
        lines = levstring.split("\n")
        levstring = "\n".join([lines[0]] + [indent + x.lstrip() for x in lines[1:]])

        return temp % ("" if self.name is None else self.name, repr(values), levheader + levstring)

 def __repr__(self):
     output = 'file name : ' + self.fileName + '\n'
     for m in self.file_metadata.keys():
         output += m + ' : ' + str(self.file_metadata[m]) + '\n'
     output += '\nchannels listed by data groups:\n'
     for d in self.masterChannelList.keys():
         if d is not None:
             output += d + '\n'
         for c in self.masterChannelList[d]:
             output += '  ' + c + ' : ' + str(self[c]['description']) + '\n'
             output += '    ' + array_repr(self[c]['data'], precision=3, suppress_small=True) \
                 + ' ' + self[c]['unit'] + '\n'
     return output

    def __repr__(self):
        temp = 'Categorical: %s\n%s\n%s'
        values = np.asarray(self)
        levheader = 'Levels (%d): ' % len(self.levels)
        levstring = np.array_repr(self.levels,
                                  max_line_width=60)

        indent = ' ' * (levstring.find('[') + len(levheader) + 1)
        lines = levstring.split('\n')
        levstring = '\n'.join([lines[0]] + [indent + x.lstrip() for x in lines[1:]])

        return temp % ('' if self.name is None else self.name,
                       repr(values), levheader + levstring)

def area_precision_recall(detector_response, actual):
    if type(actual) is str:
        actual_img = cv2.imread(actual, flags=-1)
    else:
        actual_img = actual
    assert actual_img.shape == detector_response.shape, \
        "Actual shape: {0} Got: {1}".format(actual_img.shape, detector_response.shape)
    assert all_binary(detector_response), np.array_repr(np.unique(detector_response))
    assert all_binary(actual_img), actual

    pr = area_precision(detector_response, actual_img)
    rec = area_recall(detector_response, actual_img)
    return pr, rec

    def save_colormap(self, event):
        import textwrap

        template = textwrap.dedent('''
        from matplotlib.colors import LinearSegmentedColormap
        from numpy import nan, inf

        # Used to reconstruct the colormap in pycam02ucs.cm.viscm
        parameters = {{'xp': {xp},
                      'yp': {yp},
                      'min_Jp': {min_Jp},
                      'max_Jp': {max_Jp}}}

        cm_data = {array_list}

        test_cm = LinearSegmentedColormap.from_list(__file__, cm_data)


        if __name__ == "__main__":
            import matplotlib.pyplot as plt
            import numpy as np

            try:
                from pycam02ucs.cm.viscm import viscm
                viscm(test_cm)
            except ImportError:
                print("pycam02ucs not found, falling back on simple display")
                plt.imshow(np.linspace(0, 100, 256)[None, :], aspect='auto',
                           cmap=test_cm)
            plt.show()
        ''')

        rgb, _ = self.cmap_model.get_sRGB(num=256)
        with open('/tmp/new_cm.py', 'w') as f:
            array_list = np.array_repr(rgb, max_line_width=78)
            array_list = array_list.replace('array(', '')[:-1]

            xp, yp = self.cmap_model.bezier_model.get_control_points()

            data = dict(array_list=array_list,
                        xp=xp,
                        yp=yp,
                        min_Jp=self.cmap_model.min_Jp,
                        max_Jp=self.cmap_model.max_Jp)

            f.write(template.format(**data))

            print("*" * 50)
            print("Saved colormap to /tmp/new_cm.py")
            print("*" * 50)

def compare_response_to_truth(detector_response, actual, cascade=False, thresh=10):
    if type(actual) is str:
        actual_img = cv2.imread(actual, flags=-1)
    else:
        actual_img = actual
    assert actual_img.shape == detector_response.shape, \
        "Actual shape: {0} Got: {1}".format(actual_img.shape, detector_response.shape)
    assert all_binary(detector_response), np.array_repr(np.unique(detector_response))
    assert all_binary(actual_img), actual

    tp = true_positive(detector_response, actual_img, cascade, thresh)
    fp = false_postive(detector_response, actual_img, cascade, thresh)
    fn = false_negative(detector_response, actual_img, cascade, thresh)
    return tp, fp, fn

    def format_molecule_for_numpy(self, npobj=True):
        """Returns a NumPy array of the non-dummy atoms of the geometry
        in Cartesian coordinates in Angstroms with element encoded as
        atomic number. If *npobj* is False, returns representation of
        NumPy array.

        """
        import numpy as np
        factor = 1.0 if self.PYunits == 'Angstrom' else psi_bohr2angstroms
        self.update_geometry()

        # TODO fn title is format_mol... but return args not compatible
        geo = []
        for i in range(self.natom()):
            [x, y, z] = self.atoms[i].compute()
            geo.append([self.Z(i), x * factor, y * factor, z * factor])

        nparr = np.array(geo)
        return nparr if npobj else np.array_repr(nparr)