matplotlib绘图基本方法

Dev
python

设置中文编码

1
# -*- coding: utf-8 -*-

头文件

1
2
3
4
import numpy as np
import matplotlib.pyplot as plt
import pylab
from matplotlib.legend import Legend

直方图(histogram)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#N：表示横坐标点个数
#m：对比方案个数
def getHistogram(data, my_title):
    color = ['gray','green','blue','magenta']
    N = 6
    fs = 20 # font size
    ind = np.arange(N)  # the x locations for the groups
    width = 0.2       # the width of the bars, 1/(m+1)
    pylab.grid(True)
    # pylab.title(my_title, fontsize = fs)
    pylab.ylim((-25,15))
    #plt.ylim((0,7.5))
    pylab.bar(ind-2*width, data[0], width, color=color[0],label='MBE3',edgecolor=color[0])
    pylab.bar(ind-1*width, data[1], width, color=color[1],label='PRIVATUS',edgecolor=color[1])
    pylab.bar(ind+0*width, data[2], width, color=color[2],label='OPPEMS',edgecolor=color[2])
    pylab.bar(ind+1*width, data[3], width, color=color[3],label='DPMRRS',edgecolor=color[3])
    
    # add some text for labels, title and axes ticks
    pylab.xlabel(r'$\epsilon$', fontsize = fs)
    #pylab.ylabel('mutual information', fontsize = fs)
    pylab.ylabel('extra cost/$', fontsize = fs)
    pylab.xticks(ind, ('0.15', '0.25', '0.35', '0.45', '0.55','0.65'), fontsize = fs)
    pylab.yticks(fontsize = fs)
    pylab.legend(ncol = 4, loc = 'upper left')
    pylab.show()

折线图(plot)

1
2
3
4
5
6
7
8
9
10
11
12
13
def getLine(data,my_title):
    plt.grid(True)
    fs = 20
    X = [100, 200, 300, 400, 500]
    plt.xlabel('number of invalid noises', fontsize = fs)
    plt.ylabel('extra cost/$', fontsize = fs)
    # plt.ylabel('mutual information', fontsize = fs)
    plt.xlim((0,600))
    plt.xticks(fontsize = fs)
    plt.yticks(fontsize = fs)
    # plt.title(my_title, fontsize = fs)
    plt.plot(X, data, 'ro-',linewidth=4)
    plt.show()

散点图(dot)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def plotDots(data):
    plt.grid(True)
    fs = 20
    X = range(96)
    plt.xlabel('time', fontsize = fs)
    # plt.ylabel('price/($/kwh)', fontsize = fs)
    plt.ylabel('mutual information', fontsize = fs)
    plt.xlim((-4,100))
    plt.ylim((0,0.03))
    plt.xticks([])
    plt.yticks([])
    # plt.title(my_title, fontsize = fs)
    plt.plot(X, data, 'go',label='price')
    plt.plot(X,y1, 'b--',label='$p_l$')
    plt.plot(X,y2, 'k--',label='$p_h$')
    # plt.legend(fontsize = fs, ncol=3)
    plt.show()

饼图(pie)

1
2
3
4
5
6
7
#sum(data)=1
def plotPie(data):
    plt.title('pie chart')
    labels = ['China', 'Japan', 'America']
    # labeldistance>1, label就在饼图外面
    plt.pie(x, labels=labels, autopct='%1.1f%%',labeldistance=1.2)
    plt.show()
分享到

java-matlab2014a混合编程

Dev
Java, Matlab

第一步

  • 编写需要调用的matlab函数，可以多个文件一起编译
  • 在matlab的shell框中输入deploytool，回车
  • 在弹出的菜单中选中library compiler(这个根据实际情况自己决定)
  • 左上角选中java package。点击稍右侧的+号添加文件
  • 修改Library Name和类名
  • Runtime downloaded from web和runtime included in package视情况决定
  • 点击右上角的Package按钮开始编译

第二步

  • 首先需要将Matlab\R2014a\toolbox\javabuilder\jar中的javabuilder.jar放入java工程文件夹内(最好这么做)
  • 将编译完成的xxx.jar包放入java工程文件夹内(最好这么做)
  • 在eclipse的Package Explore中右键工程名
  • Build path -> configure build path，然后点击Add External JARs添加上面的2个jar包

第三步

  • 首先导入jar包

    1
    2
    import com.mathworks.toolbox.javabuilder.*;
    import xxx.Class1;

  • 使用函数时

    1
    2
    3
    4
    5
    6
    Class1 class = new Class1();
    Object[] result = t = new Object[2]; //这里必须用数组形式，至少在matlab2014a里是这样的
    result = class.functionName(2, argument1, srgument2, argument3); //2表示返回结果的个数为2
    MWNumericArray temp = (MWNumericArray)result[0]; //第一个结果是数组                    
    double[][] recv = (double[][]) temp.toDoubleArray(); //还有toInt/FloatArray以及toString等用法
    int box = Integer.valueOf(result[0].toString()); //第二个结果是一个int型整数.
分享到

java序列化

Dev
Java

一. 描述

  • 在网络通信和数据存储方面很有用
  • 对于需要序列化的类，应该在其实现时在类头部加上implements Serializable

二. 示例

  • 序列化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public byte[] functionName (ClassType sample) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(sample);
            byte[] bytes = baos.toByteArray();
            System.out.println("...serialization complete."); 
            return bytes;
        } catch (Exception e) {
            System.out.println("...serialization failed.");
        }
        return null;
    }

  • 反序列化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public ClassType deserializeCFC(byte[] bytes) {
        try {
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return (ClassType) ois.readObject();
        } catch (Exception e) {
            System.out.println("...deserialization failed.");
        }
        return null;
    }
分享到

cpp-string

Dev
Cpp

toupper, tolower

地球人都知道 C++ 的 string 没有 toupper ，好在这不是个大问题，因为我们有 STL 算法：

1
2
3
4
5
string s("heLLo");
transform(s.begin(), s.end(), s.begin(), toupper);
cout << s << endl;
transform(s.begin(), s.end(), s.begin(), tolower);
cout << s << endl;

当然，我知道很多人希望的是 s.to_upper() ，但是对于一个这么通用的 basic_string 来说，的确没办法把这些专有的方法放进来。如果你用 boost stringalgo ，那当然不在话下，你也就不需要读这篇文章了。

trim

我们还知道 string 没有 trim ，不过自力更生也不困难，比 toupper 来的还要简单：

1
2
3
4
5
string s("   hello   ");
s.erase(0, s.find_first_not_of(" /n"));
cout << s << endl;
s.erase(s.find_last_not_of(' ') + 1);
cout << s << endl;

注意由于 find_first_not_of 和 find_last_not_of 都可以接受字符串，这个时候它们寻找该字符串中所有字符的 absence ，所以你可以一次 trim 掉多种字符。

erase

string 本身的 erase 还是不错的，但是只能 erase 连续字符，如果要拿掉一个字符串里面所有的某个字符呢？用 STL 的 erase + remove_if 就可以了，注意光 remove_if 是不行的。

1
2
string s("   hello, world. say bye   ");
s.erase(remove_if(s.begin(),s.end(), bind2nd(equal_to<char>(), ' ')), s.end());

上面的这段会拿掉所有的空格，于是得到 hello,world.saybye。

replace

string 本身提供了 replace ，不过并不是面向字符串的，譬如我们最常用的把一个 substr 换成另一个 substr 的操作，就要做一点小组合：

1
2
3
4
string s("hello, world");
string sub("ello, ");
s.replace(s.find(sub), sub.size(), "appy ");
cout << s << endl;

输出为 happy world。注意原来的那个 substr 和替换的 substr 并不一定要一样长。

startwith, endwith

这两个可真常用，不过如果你仔细看看 string 的接口，就会发现其实没必要专门提供这两个方法，已经有的接口可以干得很好：

1
2
3
4
5
6
7
string s("hello, world");
string head("hello");
string tail("ld");
bool startwith = s.compare(0, head.size(), head) == 0;
cout << boolalpha << startwith << endl;
bool endwith = s.compare(s.size() - tail.size(), tail.size(), tail) == 0;
cout << boolalpha << endwith << endl;

当然了，没有

1
s.startwith("hello")

这样方便。

toint, todouble, tobool…

这也是老生常谈了，无论是 C 的方法还是 C++ 的方法都可以，各有特色：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
string s("123");
int i = atoi(s.c_str());
cout << i << endl;
    
int ii;
stringstream(s) >> ii;
cout << ii << endl;
    
string sd("12.3");
double d = atof(sd.c_str());
cout << d << endl;
    
double dd;
stringstream(sd) >> dd;
cout << dd << endl;
    
string sb("true");
bool b;
stringstream(sb) >> boolalpha >> b;
cout << boolalpha << b << endl;

C 的方法很简洁，而且赋值与转换在一句里面完成，而 C++ 的方法很通用。

split

这可是件麻烦事，我们最希望的是这样一个接口： ‘’’s.split(vect, ‘,’)’’’ 。用 STL 算法来做有一定难度，我们可以从简单的开始，如果分隔符是空格、tab 和回车之类，那么这样就够了：

1
2
3
4
5
6
string s("hello world, bye.");
vector<string> vect;
vect.assign(
    istream_iterator<string>(stringstream(s)),
    istream_iterator<string>()
);

不过要注意，如果 s 很大，那么会有效率上的隐忧，因为 stringstream 会 copy 一份 string 给自己用。

concat

把一个装有 string 的容器里面所有的 string 连接起来，怎么做？希望你不要说是 hand code 循环，这样做不是更好？

1
2
3
4
5
6
vector<string> vect;
vect.push_back("hello");
vect.push_back(", ");
vect.push_back("world");
    
cout << accumulate(vect.begin(), vect.end(), string(""));

不过在效率上比较有优化余地。

reverse

其实我比较怀疑有什么人需要真的去 reverse 一个 string ，不过做这件事情的确是很容易：

1
std::reverse(s.begin(), s.end());

上面是原地反转的方法，如果需要反转到别的 string 里面，一样简单：

1
s1.assign(s.rbegin(), s.rend());

效率也相当理想。

解析文件扩展名

字数多点的写法：

1
2
3
std::string filename("hello.exe");
std::string::size_type pos = filename.rfind('.');
std::string ext = filename.substr(pos == std::string::npos ? filename.length() : pos + 1);

不过两行，合并成一行呢？也不是不可以：

1
std::string ext = filename.substr(filename.rfind('.') == std::string::npos ? filename.length() : filename.rfind('.') + 1);

我们知道，rfind 执行了两次。不过第一，你可以希望编译器把它优化掉，其次，扩展名一般都很短，即便多执行一次，区别应该是相当微小。

分享到

cpp-unordered_map

Dev
Cpp

unordered_map的基本用法如下：

1
2
3
4
5
6
7
unordered_map<string, int> map ;
map["zhangsan"]=3;
map["lisi"]=9;
int x = map["lisi"]; //9
unordered_map<string, int>::iterator it;
for (it=map.begin(); it!=map.end(); it++)
    cout<<it->first<<" "<<it->second<<endl;

关于支持复杂类型key，unordered_map支持string类型，但是自定义类型不行。下面给出通过重载使得unordered_map支持自定义类型的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
struct ReadingPair //作为key的类型
{
    double real, modified;
    ReadingPair() {
        this->real = 0;
        this->modified = 0;
    }
    // 判断两个示例是否相等的函数
    bool operator== (const struct ReadingPair& other) const {
        if (real != other.real || modified != other.modified)
            return false;
        return true;
    }
};
另外还需要一个hash函数，重载操作符(),计算key的哈希值。
一个比较直观的方法是特化（specialize）std::hash模板。
namespace std {
    template <>
    struct hash<ReadingPair> {
        std::size_t operator()(const ReadingPair& k) const {
            // Compute individual hash values for first,
            // second and third and combine them using XOR
            // and bit shifting:
            using std::hash; //重要
            return ((hash<double>()(k.real)
                ^ (hash<double>()(k.modified) << 1)) >> 1);
        }
    };
}
由于unordered_map不需要排序，所以不需要重载<符号。

分享到