php-php的类

关于PHP的类 http://php.net/manual/zh/language.oop5.php

(本来想顺便学学nodejs的,但是谁有那么多精力啊。。还有js学的像狗屎一样= =)

<?php
class Test
{
    private $name; // 可以定义类的访问权限
    public function __construct($name) //构造函数
    {
        $this->name = $name;
    }
    public function echoname
    {
        echo $this->name;
    }
}
$a = new Test("This is a.");
$a->echoname();
  • 构造函数重载我不会,有时间再更新吧。。
  • 先记录这些。

Linux-SELinux-httpd无法访问

目录的问题

由于SELinux造成的httpd中的目录无法访问,可以使用

  • chcon -R -t httpd_user_content_t <path to web files>
  • chcon -R -t httpd_sys_content_t <path to web files>

mark一个网站()[http://www.jb51.net/os/RedHat/1303.html]

文件夹访问权限

以上方法解决了SELinux的问题,但是我的目录依然没有访问权限。

然后看了一下文件的基本属性: -rw-r--r--. 1 root root 21 11月 11 12:27 index.html

应该也是没有问题的。

再查SElinux

随后使用cat /var/log/messages探索一番,依然没有找到问题所在——SELinux没有报错。

防火墙的问题?不是阿。因为我本身是在内网访问,防火墙应该不会出问题。

那应该是什么问题呢?

配置文件

终于在配置文件中找到了问题。

apache在进入2.4.*以后,不再使用Allow from all这种形式了,取而代之,使用Require from granted这种格式。晕,就是在此处,<Directory>没有设置好,坑了好久阿。。

相对的我这几天一直都在deepin下开发——因为apt-get得到的apache之前比较习惯,此外deepin没有se也是省了很多功夫。不过通过这一次,总算是把问题解决了!

鼓励!

从grub rescue修复

修复grub-rescue模式

今天删除了一个多余的分区,结果grub找不到原来的启动mod了,也是学习了。

grub-rescue模式中只能用ls, insmod, set root= , set prefix= ,这几个命令。

使用ls显示所有的磁盘。
然后ls (hd0, X)/boot/grub2 查看启动的盘符。
set root=(hd0, X);
set prefix=(hd0, X)/boot/grub2
insmod normal
normal

发现没搞定,重启还是不幸。

使用# grub2-install /dev/sda

然后就搞定= =

线性时间选择

定义

在给定线性序集中n个元素和一个整数k,要求找出n个元素中第k小的数。

方法一

线性时间选择,可以使用堆排序,这样就可以在$O(n+klog_n)=O(n)_的时间内找到的k小的元素。

方法二

使用快速排序中的分块算法,对所需要选择的数组分块,分完以后再在剩余的部分中,寻找(k – 减去分块的大小)

代码如下:

template <class Type>
int Partition(Type a[], int p, int r)
{
    int i = p;
        j = r+1;
    Type x = a[p];
    while(1)
    {
        while(a[++i] < x);
        while(a[--j] > x);
        if(i >= j) break;
        swap(a[i], a[j]);
    }
    a[p] = a[j];
    a[j] = x;
    return j;
}
template <class Type>
int RandomPartition(Type a[], int p, int r)
{
    int i = Random(p, r);
    swap(a[i], a[p]);
    return Partition(a, p, r);
}
template <class Type>
Type RandomizedSelect(Type a[], int p, int r, int k)
{
    if(p == r) return a[p];
    int i = RandomPartition(a, p, r);
    j = i - p + 1; // 分块的大小
    if(k <= j) return RandomizedSelect(a, p, i, k);
    else return RandomizedSelect(a, i+1, r, k-j);
}

但是此方法在最差的情况下需要$n^2$的时间,比如在寻找最小元素时,总是在最大的元素划分。

尽管如此,平均效率还是不错的。

方法三

我还是比较喜欢直接看代码= =

template <class Type>
Type Select(Type a[], int p, int r, int k)
{
    if (r - p < 75)
    {
        sort(&a[p], &a[r]);
        return a[p+k-1];
    }
    for(int i = 0; i <= (r-p-4)/5; i++)
        Type x = Select(a, p, p+(r-p-4)/5, (r-p-4)/10);
    int i = Partition(a, p, r, x);
    j = i - p + 1;
    if(k <= j) return Select(a, p, i, k);
    else return Select(a, i+1, r, k-j)
}

n种方法实现并行枚举排序

这篇文章一直没有写,因为并行计算的报告写的比较潦草。此外,没有实现fork。

文件的源代码贴在 https://github.com/Svtter/workspace/tree/master/parallel/enum_sort

实现了Java, MPI, openmp, pthread, win32, MFC, .NET 的并行枚举排序,测试机是双核四线程的ThinkpadE430.

MPI的环境是archlinux . openmpi

贴一个MPI的源代码, 运行结果都在源代码对应的文件夹中保存,这里就不贴了。

/*=============================================================================
#
# Author: svtter - svtter@qq.com
#
# QQ : 57180160
#
# Last modified: 2014-11-02 17:08
#
# Filename: enum_sort_MPI.cpp
#
# Description: 
#
=============================================================================*/
#include "mpi.h"
#include <stdio.h>
#include <math.h>
#include <sys/time.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 10000
#define PMAX 1000
void build(int a[], int b[])
{
    srand(time(NULL));
    for(int i = 1; i <= MAXN; i++)
        a[i] = b[i] = random()%PMAX;
}
//serial enum sort
double serial_enum_sort(int a[], int at[])
{
    double t1, t2;
    t1 = MPI_Wtime();
    int k, i, j;
    for(i = 1; i <= MAXN; i++)
    {
        k = 1;
        for(j = 1; j <= MAXN; j++)
            if(a[i] > a[j] || (a[i] == a[j] && i > j))
                k++;
        at[k] = a[i];
    }
    t2 = MPI_Wtime();
    return (t2 - t1);
}
// 用于调试数组
void debug(int a[], int len)
{
    for(int i = 1; i <= len; i++)
    {
        fprintf(stderr, "%5d", a[i]);
    }
    fprintf(stderr, "\n");
}
int a[MAXN+10], b[MAXN+10], at[MAXN+10], bt[MAXN+10];
void ensort(int rank[], int &myid, int &numprocs)
{
    int i, j, k;
    for(i = myid; i <= MAXN; i+=numprocs)
    {
        k = 1;
        for(j = 1; j <= MAXN; j++)
        {
            if(b[i] > b[j] || (b[i] == b[j] && (i > j)))
                k++;
        }
        rank[i] = k;
    }
}
int main(int argc, char *argv[])
{
    int myid, numprocs;
    int namelen;
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    double c1 = 0, c2;
    double start, end;
    int i;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
    MPI_Get_processor_name(processor_name, &namelen);
    // fprintf(stderr, "Hello world! Processor %d of %d on %s\n", myid, numprocs, processor_name);
    //serial
    if(myid == 0)
    {
        build(a, b);
        c1 = serial_enum_sort(a, at);
        cout << "original array is: " << endl;
        debug(a, 100);
        cout << endl;
        cout << "serial sorted array is: " << endl;
        debug(at, 100);
        cout << endl;
        cout << "serial cost time is: " << c1 << endl;
        cout << endl;
    }
    int con[numprocs][MAXN+10];
    int pt[MAXN+10];
    memset(con ,0, sizeof(con));
    memset(pt,0, sizeof(pt));
    // int **con = new int*[numprocs];
    // for(int i = 0; i < numprocs; i++)
        // con[i] = new int[MAXN+10];
    start = MPI_Wtime();
    // P0 send b to ALL
    MPI_Bcast(b, MAXN+10, MPI_INT, 0, MPI_COMM_WORLD);
    ensort(pt, myid, numprocs);
    // Gather
    MPI_Gather(pt, MAXN+10, MPI_INT, con[myid], MAXN+10, MPI_INT, 0, MPI_COMM_WORLD);
    // if(myid == 0)
    // {
        // fprintf(stderr, "myid: %d\n", myid);
        // fprintf(stderr, "con: %d\n", myid);
        // debug(con[1], 100);
        // fprintf(stderr, "pt: %d\n", myid);
        // debug(pt, 100);
        // fprintf(stderr, "\n");
    // }
    if(myid == 0)
    {
        int j;
        // for(i = 0; i < numprocs; i++)
        // {
            // printf("i: %d\n", i);
            // for(j = 1; j <= MAXN; j++)
                // printf("%5d", con[i][j]);
            // puts("");
        // }
        // rank[k] = i
        for(i = 0; i < numprocs; i++)
            for(j = 1; j <= MAXN; j++)
                bt[con[i][j]] = b[j];
        // fprintf(stderr, "bt: \n");
        cout << "parallel sorted array is: " << endl;
        debug(bt, 100);
        cout << endl;
        end = MPI_Wtime();
        c2 = end - start;
        fprintf(stderr, "parallel cost time is: %lf\n", c2);
        fprintf(stderr, "加速比为: %lf\n", c1 / c2);
    }
    // for(i = 0; i < numprocs; i++)
        // delete con[i];
    // delete con;
    MPI_Finalize();
    return 0;
}

并行计算非常有趣,有时间肯定会再在这条道路上探寻…

vim-tips

拾遗

  1. 使用q:查看历史命令
  2. @*执行寄存器命令

高亮特定文件

" for ROS:
augroup filetypedetect
    au BufRead,BufNewFile *.launch set filetype=xml
augroup END