diff --git a/CMakeLists.txt b/CMakeLists.txt
index 13ffd60..fa01c46 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,6 +10,7 @@ option(GCTL_NETCDF "Use the NetCDF library" ON)
 option(GCTL_FFTW3 "Use the FFTW3 library" ON)
 option(GCTL_EEMD "Use the EEMD library" ON)
 option(GCTL_OPENBLAS "Use the Openblas library" OFF)
+option(GCTL_EXPRTK "Use the ExprTK library" ON)
 option(GCTL_CHECK_BOUNDER "Check array's index" OFF)
 option(GCTL_CHECK_SIZE "Check array's size" OFF)
 # 传递安装地址给编译期宏变量
@@ -24,6 +25,7 @@ message(STATUS "[GCTL] Use the NetCDF library: " ${GCTL_NETCDF})
 message(STATUS "[GCTL] Use the FFTW3 library: " ${GCTL_FFTW3})
 message(STATUS "[GCTL] Use the EEMD library: " ${GCTL_EEMD})
 message(STATUS "[GCTL] Use the Openblas library: " ${GCTL_OPENBLAS})
+message(STATUS "[GCTL] Use the ExprTK library: " ${GCTL_EXPRTK})
 message(STATUS "[GCTL] Check Bounder: " ${GCTL_CHECK_BOUNDER})
 message(STATUS "[GCTL] Check Size: " ${GCTL_CHECK_SIZE})
 
diff --git a/GCTLConfig.cmake.in b/GCTLConfig.cmake.in
index bc9dc79..8713ff0 100644
--- a/GCTLConfig.cmake.in
+++ b/GCTLConfig.cmake.in
@@ -15,6 +15,7 @@ set(@PROJECT_NAME@_FFTW3 @GCTL_FFTW3@)
 set(@PROJECT_NAME@_EEMD @GCTL_EEMD@)
 set(@PROJECT_NAME@_OPENMP @GCTL_OPENMP@)
 set(@PROJECT_NAME@_OPENBLAS @GCTL_OPENBLAS@)
+set(@PROJECT_NAME@_EXPRTK @GCTL_EXPRTK@)
 set(@PROJECT_NAME@_CHECK_BOUNDER @GCTL_CHECK_BOUNDER@)
 set(@PROJECT_NAME@_CHECK_SIZE @GCTL_CHECK_SIZE@)
 
@@ -23,6 +24,7 @@ message(STATUS "[GCTL] Use the FFTW3 library: " @GCTL_FFTW3@)
 message(STATUS "[GCTL] Use the EEMD library: " @GCTL_EEMD@)
 message(STATUS "[GCTL] Use the OpenMP library: " @GCTL_OPENMP@)
 message(STATUS "[GCTL] Use the Openblas library: " @GCTL_OPENBLAS@)
+message(STATUS "[GCTL] Use the ExprTK library: " @GCTL_EXPRTK@)
 message(STATUS "[GCTL] Check Bounder: " @GCTL_CHECK_BOUNDER@)
 message(STATUS "[GCTL] Check Size: " @GCTL_CHECK_SIZE@)
 
diff --git a/config.h.in b/config.h.in
index 8ff890e..676698d 100644
--- a/config.h.in
+++ b/config.h.in
@@ -4,5 +4,6 @@
 #cmakedefine GCTL_FFTW3
 #cmakedefine GCTL_EEMD
 #cmakedefine GCTL_OPENBLAS
+#cmakedefine GCTL_EXPRTK
 #cmakedefine GCTL_CHECK_BOUNDER
 #cmakedefine GCTL_CHECK_SIZE
\ No newline at end of file
diff --git a/example/text_io_ex.cpp b/example/text_io_ex.cpp
index b2fbbb5..f864ca0 100644
--- a/example/text_io_ex.cpp
+++ b/example/text_io_ex.cpp
@@ -32,33 +32,31 @@ using namespace gctl;
 
 int main(int argc, char const *argv[]) try
 {
-/*
-    dsv_io tc;
+
+    dsv_io tc, tout;
     tc.set_delimeter('|');
     tc.load_text("tmp/world_data", ".txt", BothHead);
-    tc.info();
+    //tc.info();
 
-    //_1s_vector name = tc.get_row_names();
-    //display_vector(name);
+    //tc.set_column_type(Int, "IndepYear_n");
+    //tc.filt_column("IndepYear_n < 0", {"IndepYear_n"}, {"Name_s", "Population_n", "GNP_n"}, tout);
 
-    _1s_array name;
-    tc.get_column("Name_s", name);
-    name.show(std::cout, ',');
+    tc.filt_column("America", "Continent_s", {"Name_s", "Population_n", "GNP_n"}, tout);
+    //tc.match_column("America", "Continent_s", {}, tout);
 
-    tc.get_row("AUS", name);
-    name.show(std::cout, ',');
-
-    tc.save_csv("out");
-*/
+    tout.set_delimeter('|');
+    tout.save_text("out");
 
+/*
     geodsv_io tc;
     tc.load_text("tmp/topo", ".txt", ColumnHead);
-    tc.cell(0, 0, std::string("x (m)"));
-    tc.cell(0, 1, std::string("y (m)"));
-    tc.cell(0, 2, std::string("elevation (m)"));
+    tc.set_column_names({"x (m)", "y (m)", "elev (m)"});
+    tc.set_column_type(Float, "x (m)");
+    tc.set_column_type(Float, "y (m)");
+    tc.set_column_type(Float, "elev (m)");
 
     array<point3dc> topo;
-    tc.get_column_point3dc(0, 1, 2, topo);
+    tc.get_column_point3dc(topo, 1, 2, 3);
 
     std::clog << std::setprecision(11) << topo.front().z << "\n";
     std::clog << topo.back().x << "," << topo.back().y << "," << topo.back().z << "\n";
@@ -66,17 +64,36 @@ int main(int argc, char const *argv[]) try
     display_vector(tc.get_annotoations(), std::clog, '\n');
     display_vector(tc.get_head_records(), std::clog, '\n');
 
+    //tc.column_output("C3", Disable);
+    
+    array<double> elev;
+    tc.get_column(elev, "elev (m)");
+    elev.for_each([](double &d, size_t i){d += 100.0;});
+
+    tc.add_column(2, "elev_plus");
+    tc.fill_column(elev, "elev_plus");
+
+    tc.add_column(-1, "dist");
+    tc.cal_column("dist := sqrt(C1*C1 + C3*C3)", {"dist", "C1", "C3"});
+
+    tc.add_row(3);
+    tc.fill_row(array<double>{5.5, 4.4, 3.3, 2.2, 1.1}, 3);
+
+    geodsv_io out_table;
+    tc.filt_column("dist > 1000", {"dist"}, {"x (m)", "y (m)", "elev (m)"}, out_table);
+    out_table.save_text("out2");
+
     _1s_vector s = tc.get_tags();
     s.push_back("Elev = 1000");
     tc.set_tags(s);
     tc.save_csv("out");
 
     double c = 4.25242153654;
-    tc.cell(1, 0, c, 12);
-    std::clog << std::setprecision(12) << tc.cell<double>(1, 0) << "\n";
+    tc.cell(c, 2, 1, 12);
+    std::clog << std::setprecision(12) << tc.cell<double>(2, 1) << "\n";
 
     tc.info();
-
+*/
     return 0;
 }
 catch(std::exception &e)
diff --git a/installer b/installer
deleted file mode 100755
index fd9d6e5..0000000
--- a/installer
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/bin/bash
-
-if [[ $# == 0 || ${1} == "help" ]]; then
-	echo "Compiles executables/libraries and maintains installed files. Two tools 'Cmake' and 'stow' are empolyed here. For more information, see https://cmake.org and https://www.gnu.org/software/stow/."
-	echo ""
-	echo "School of Earth Sciences, Zhejiang University"
-	echo "Yi Zhang (yizhang-geo@zju.edu.cn)"
-	echo ""
-	echo "Usage: ./config.sh [option] [Cmake options]"
-	echo ""
-	echo "Options:"
-	echo "(1) configure: Configure Cmake project(s). This option could take extra Cmake options as in <option>=<value>."
-	echo "(2)     build: Build executables/libraries."
-	echo "(3)   install: Install executables/libraries to the directory of CMAKE_INSTALL_PREFIX and sym-links them to the target address. This offers a quick and clean remove of the installed files."
-	echo "(4)     clean: Clean build/ folder(s)."
-	echo "(5) uninstall: Delete the installed files and sym-links."
-	echo "(6)      info: Print out current setups."
-	echo "(7)      help: Show help information."
-	exit 0
-fi
-
-package=gctl
-address=/opt/stow
-taress=/usr/local
-option="-DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${address}/${package}"
-
-if [[ $# -gt 1 ]]; then
-	for opt in "$@"; do
-		if [[ ${opt} != "configure" ]]; then
-			option="${option} -D${opt}"
-		fi
-	done
-fi
-
-if [[ ${1} == "configure" && ! -d "build/" ]]; then
-	mkdir build && cd build && cmake .. ${option}
-elif [[ ${1} == "configure" ]]; then
-	cd build && rm -rf * && cmake .. ${option}
-elif [[ ${1} == "build" ]]; then
-	cd build && make
-elif [[ ${1} == "install" ]]; then
-	cd build && sudo make install
-	sudo stow --dir=${address} --target=${taress} -S ${package}
-elif [[ ${1} == "clean" ]]; then
-	rm -rf build/
-elif [[ ${1} == "uninstall" ]]; then
-	sudo stow --dir=${address} --target=${taress} -D ${package}
-	sudo rm -rf ${address}/${package}
-elif [[ ${1} == "info" ]]; then
-	echo "package name:" ${package}
-	echo "stow address:" ${address}
-	echo "target address:" ${taress}
-	echo "Cmake options:" ${option}
-fi
diff --git a/lib/core/array.h b/lib/core/array.h
index 5bd23d7..5c0a5ad 100644
--- a/lib/core/array.h
+++ b/lib/core/array.h
@@ -511,27 +511,27 @@ namespace gctl
 		 * @param[in]  np2          Standard deviation (Gauss) or hig bound value (Even).
 		 * @param[in]  mode         Random types. 'RdNormal' for Gaussian distributed numbers and 
 		 * 'RdUniform' for even distributed numbers.
-		 * @param[in] seed          Random seed.
+		 * @param[in] seed          Random seed. Input 0 to select the seed based on the current time.
 		 */
 		void random_float(ArrValType np1, ArrValType np2, random_type_e mode = RdNormal, unsigned int seed = 0);
 
 		/**
 		 * @brief      Initialize the array with selected random types.
 		 *
-		 * @param[in]  np1          Mean (Gauss) or low bound value (Even)
-		 * @param[in]  np2          Standard deviation (Gauss) or hig bound value (Even).
-		 * @param[in] seed          Random seed.
+		 * @param[in]  np1          Low bound value.
+		 * @param[in]  np2          Hig bound value.
+		 * @param[in] seed          Random seed. Input 0 to select the seed based on the current time.
 		 */
 		void random_int(ArrValType np1, ArrValType np2, unsigned int seed = 0);
 
 		/**
 		 * @brief Set elements' value as a sequent.
 		 * 
-		 * @param st_val  Start value.
-		 * @param inc Increasement.
-		 * @param st_id Start index.
-		 * @param size Operating size.
-		 * @param space Indexing spacing.
+		 * @param st_val  Start value of the sequent.
+		 * @param inc Increasement of the sequent.
+		 * @param st_id Start index. The default starts from the first element
+		 * @param size Operating size. The default operates on all elements
+		 * @param space Indexing spacing. you can skip elements when create the sequent. The default is no skipping.
 		 */
 		void sequence(ArrValType st_val, ArrValType inc, size_t st_id = 0, 
 			size_t size = std::numeric_limits<size_t>::max(), size_t space = 0);
diff --git a/lib/gctl_config.h b/lib/gctl_config.h
index 5971345..4fba59e 100644
--- a/lib/gctl_config.h
+++ b/lib/gctl_config.h
@@ -4,5 +4,6 @@
 #define GCTL_FFTW3
 #define GCTL_EEMD
 /* #undef GCTL_OPENBLAS */
+#define GCTL_EXPRTK
 /* #undef GCTL_CHECK_BOUNDER */
 /* #undef GCTL_CHECK_SIZE */
diff --git a/lib/io/dsv_io.cpp b/lib/io/dsv_io.cpp
index 4817d90..1115f62 100644
--- a/lib/io/dsv_io.cpp
+++ b/lib/io/dsv_io.cpp
@@ -36,7 +36,6 @@ gctl::dsv_io::dsv_io()
 	head_num_ = 0;
     row_num_ = 0;
     col_num_ = 0;
-    thead_ = ColumnHead;
 }
 
 gctl::dsv_io::~dsv_io()
@@ -53,7 +52,6 @@ gctl::dsv_io::dsv_io(std::string filename, std::string file_exten, table_headtyp
 	head_num_ = 0;
     row_num_ = 0;
     col_num_ = 0;
-    thead_ = ColumnHead;
 
     if (file_exten == ".csv") load_csv(filename, t);
     else load_text(filename, file_exten, t);
@@ -68,7 +66,6 @@ void gctl::dsv_io::clear()
 	head_num_ = 0;
     row_num_ = 0;
     col_num_ = 0;
-    thead_ = ColumnHead;
 
     destroy_vector(heads_);
     destroy_vector(annotates_);
@@ -77,11 +74,90 @@ void gctl::dsv_io::clear()
 	return;
 }
 
+void gctl::dsv_io::get_row_names(std::vector<std::string> &names)
+{
+    names.resize(row_num_);
+    for (size_t i = 1; i <= row_num_; i++)
+    {
+        names[i - 1] = table_[i][0].str_;
+    }
+    return;
+}
+
+void gctl::dsv_io::get_column_names(std::vector<std::string> &names)
+{
+    names.resize(col_num_);
+    for (size_t i = 1; i <= col_num_; i++)
+    {
+        names[i - 1] = table_[0][i].str_;
+    }
+    return;
+}
+
+void gctl::dsv_io::set_row_names(const std::vector<std::string> &names, std::string corner_name)
+{
+    for (size_t i = 1; i <= std::min(row_num_, (int) names.size()); i++)
+    {
+        table_[i][0].str_ = names[i - 1];
+    }
+
+    table_[0][0].str_ = corner_name;
+    return;
+}
+
+void gctl::dsv_io::set_column_names(const std::vector<std::string> &names)
+{
+    for (size_t i = 1; i <= std::min(col_num_, (int) names.size()); i++)
+    {
+        table_[0][i].str_ = names[i - 1];
+    }
+    return;
+}
+
+void gctl::dsv_io::set_row_type(cell_type_e t, int idx)
+{
+    if (idx > row_num_ || idx <= 0)
+    {
+        throw std::runtime_error("[gctl::dsv_io] Invalid column index.");
+    }
+
+    for (size_t i = 0; i <= col_num_; i++)
+    {
+        table_[idx][i].type_ = t;
+    }
+}
+
+void gctl::dsv_io::set_row_type(cell_type_e t, std::string name)
+{
+    set_row_type(t, name_index(name, true));
+}
+
+void gctl::dsv_io::set_column_type(cell_type_e t, int idx)
+{
+    if (idx > col_num_ || idx <= 0)
+    {
+        throw std::runtime_error("[gctl::dsv_io] Invalid column index.");
+    }
+
+    for (size_t i = 0; i <= row_num_; i++)
+    {
+        table_[i][idx].type_ = t;
+    }
+    return;
+}
+
+void gctl::dsv_io::set_column_type(cell_type_e t, std::string name)
+{
+    set_column_type(t, name_index(name, false));
+}
+
 void gctl::dsv_io::load_text(std::string filename, std::string file_exten, table_headtype_e t)
 {
     std::ifstream infile;
     open_infile(infile, filename, file_exten);
 
+    file_ = filename + file_exten;
+
     int h = 0;
     std::string tmp_line;
     std::vector<std::string> lines;
@@ -114,42 +190,78 @@ void gctl::dsv_io::load_text(std::string filename, std::string file_exten, table
     }
     infile.close();
 
-    // 首先初始化行数
-    row_num_ = lines.size();
-    table_.resize(row_num_);
+    table_.resize(lines.size());
 
-    int cn;
+    int cn, cn_max = 0;
     std::vector<std::string> tmp_cols;
-    for (size_t i = 0; i < row_num_; i++)
+    for (size_t i = 0; i < lines.size(); i++)
     {
         tmp_cols.clear();
         parse_string_to_vector(lines[i], deli_sym_, tmp_cols);
         
         // 动态调整列数
         cn = tmp_cols.size();
-        col_num_ = std::max(cn, col_num_);
+        cn_max = std::max(cn, cn_max);
 
         table_[i].resize(tmp_cols.size());
         for (size_t j = 0; j < tmp_cols.size(); j++)
         {
-            table_[i][j].str_ = tmp_cols[j];
+            table_[i][j].value(tmp_cols[j]);
         }
     }
 
     // 补齐可能的空格
     table_cell empty_cell;
-    empty_cell.str_ = "";
-    for (size_t i = 0; i < row_num_; i++)
+    for (size_t i = 0; i < table_.size(); i++)
     {
         cn = table_[i].size();
-        for (size_t j = cn; j < col_num_; j++)
+        for (size_t j = cn; j < cn_max; j++)
         {
             table_[i].push_back(empty_cell);
         }
     }
 
-    thead_ = t;
-    file_ = filename + file_exten;
+    std::vector<table_cell> empty_line;
+    if (t == NoHead) // 无表头 需要补齐空白的列头和行头
+    {
+        row_num_ = table_.size();
+        col_num_ = table_[0].size();
+
+        table_.emplace(table_.begin(), empty_line);
+        table_[0].resize(col_num_);
+
+        for (size_t i = 0; i < table_.size(); i++)
+        {
+            table_[i].emplace(table_[i].begin(), empty_cell);
+        }
+    }
+
+    if (t == ColumnHead) // 有列头 需要补齐空白的行头
+    {
+        row_num_ = table_.size() - 1;
+        col_num_ = table_[0].size();
+
+        for (size_t i = 0; i < table_.size(); i++)
+        {
+            table_[i].emplace(table_[i].begin(), empty_cell);
+        }
+    }
+
+    if (t == RowHead) // 有行头 需要补齐空白的列头
+    {
+        row_num_ = table_.size();
+        col_num_ = table_[0].size() - 1;
+
+        table_.emplace(table_.begin(), empty_line);
+        table_[0].resize(col_num_ + 1);
+    }
+    
+    if (t == BothHead) // 有行头和列头
+    {
+        row_num_ = table_.size() - 1;
+        col_num_ = table_[0].size() - 1;
+    }
+
     destroy_vector(lines);
     return;
 }
@@ -181,15 +293,50 @@ void gctl::dsv_io::save_text(std::string filename, std::string file_exten)
         outfile << "# " << annotates_[i] << std::endl;
     }
 
-    for (int i = 0; i < row_num_; i++)
+    // 单独处理第一行 即列头
+    bool line_st = false;
+    if (table_[0][0].out_ok_ && table_[0][0].str_ != "")
     {
-        outfile << table_[i][0].str_;
-        for (size_t j = 1; j < col_num_; j++)
+        outfile << table_[0][0].str_;
+        line_st = true;
+    }
+
+    for (int j = 1; j <= col_num_; j++)
+    {
+        if (line_st && table_[0][j].out_ok_ && table_[0][j].str_ != "") outfile << deli_sym_ << table_[0][j].str_; // line started
+        else if (table_[0][j].out_ok_ && table_[0][j].str_ != "") // line not started
         {
-            outfile << deli_sym_ << table_[i][j].str_;
+            outfile << table_[0][j].str_;
+            line_st = true; // start line
+        }
+    }
+
+    if (line_st) outfile << std::endl;
+
+    // 处理余下的行
+    for (int i = 1; i <= row_num_; i++)
+    {
+        line_st = false;
+
+        // 单独处理第一列 即行头
+        if (table_[i][0].out_ok_ && table_[i][0].str_ != "")
+        {
+            outfile << table_[i][0].str_;
+            line_st = true;
+        }
+
+        for (int j = 1; j <= col_num_; j++)
+        {
+            if (line_st && table_[i][j].out_ok_) outfile << deli_sym_ << table_[i][j].str_; // line started
+            else if (table_[i][j].out_ok_) // line not started
+            {
+                outfile << table_[i][j].str_;
+                line_st = true; // start line
+            }
         }
         outfile << std::endl;
     }
+    
     outfile.close();
     return;
 }
@@ -201,121 +348,580 @@ void gctl::dsv_io::save_csv(std::string filename)
     return;
 }
 
-void gctl::dsv_io::init_table(int row, int col, table_headtype_e t)
+void gctl::dsv_io::init_table(int row, int col)
 {
+    if (!table_.empty()) clear();
+    
     row_num_ = row;
     col_num_ = col;
-    thead_ = t;
-
-    table_.resize(row_num_);
-    for (size_t i = 0; i < row_num_; i++)
+    
+    // 初始的列头和行头均为空白
+    table_.resize(row_num_ + 1);
+    for (size_t i = 0; i < row_num_ + 1; i++)
     {
-        table_[i].resize(col_num_);
-        for (size_t j = 0; j < col_num_; j++)
-        {
-            table_[i][j].str_ = "";
-        }
-    }
-
-    if (t == RowHead || t == BothHead)
-    {
-        for (size_t i = 0; i < row_num_; i++)
-        {
-            table_[i][0].str_ = "row-" + std::to_string(i);
-        }
-    }
-
-    if (t == ColumnHead || t == BothHead)
-    {
-        for (size_t i = 0; i < col_num_; i++)
-        {
-            table_[0][i].str_ = "col-" + std::to_string(i);
-        }
-    }
-
-    if (t == BothHead)
-    {
-        table_[0][0].str_ = "row-idx";
+        table_[i].resize(col_num_ + 1);
     }
     return;
 }
 
-void gctl::dsv_io::set_head_records(const std::vector<std::string> &heads)
-{
-    heads_ = heads;
-    head_num_ = heads_.size();
-    return;
-}
-
-void gctl::dsv_io::set_annotoations(const std::vector<std::string> &att)
-{
-    annotates_ = att;
-    return;
-}
-
-void gctl::dsv_io::set_tags(const std::vector<std::string> &tags)
-{
-    tags_ = tags;
-    return;
-}
-
-void gctl::dsv_io::info()
+void gctl::dsv_io::info(table_headtype_e t)
 {
     std::clog << "File: " << file_ << "\n------------\n";
     std::clog << "Head(s): " << head_num_ << "\n";
     std::clog << "Annotation(s): " << annotates_.size() << "\n";
     std::clog << "Tag(s): " << tags_.size() << "\n";
-    std::clog << "------------\nColumns:\n";
+    std::clog << "------------\n";
 
-    for (size_t i = 0; i < col_num_; i++)
+    if (t == ColumnHead || t == BothHead)
     {
-        if (thead_ == ColumnHead || thead_ == BothHead)
+        std::clog << "Columns:\n";
+        for (size_t i = 1; i <= col_num_; i++)
         {
-            std::clog << table_[0][i].str_ << ": " << table_[1][i].str_ << " -> " << table_[row_num_ - 1][i].str_ << "\n";
-        }
-        else
-        {
-            std::clog << "Col-" << std::to_string(i) << ": " << table_[0][i].str_ << " -> " << table_[row_num_ - 1][i].str_ << "\n";
+            if (table_[0][i].str_ != "")
+            {
+                std::clog << table_[0][i].str_ << " | ";
+                if (table_[1][i].type_ == String) std::clog << "String | ";
+                if (table_[1][i].type_ == Int) std::clog << "Int | ";
+                if (table_[1][i].type_ == Float) std::clog << "Float | ";
+                std::clog << table_[1][i].str_ << " -> " << table_[row_num_][i].str_;
+            }
+            else
+            {
+                std::clog << "C" + std::to_string(i) << " | ";
+                if (table_[1][i].type_ == String) std::clog << "String | ";
+                if (table_[1][i].type_ == Int) std::clog << "Int | ";
+                if (table_[1][i].type_ == Float) std::clog << "Float | ";
+                std::clog << table_[1][i].str_ << " -> " << table_[row_num_][i].str_;
+            }
+
+            if (!table_[0][i].out_ok_) std::clog << " (No output)";
+            std::clog << std::endl;
         }
+        std::clog << "============\n";
+    }
+    
+    if (t == RowHead || t == BothHead)
+    {
+        std::clog << "Rows:\n";
+        for (size_t i = 1; i <= row_num_; i++)
+        {
+            if (table_[i][0].str_ != "")
+            {
+                std::clog << table_[i][0].str_ << " | ";
+                if (table_[i][1].type_ == String) std::clog << "String | ";
+                if (table_[i][1].type_ == Int) std::clog << "Int | ";
+                if (table_[i][1].type_ == Float) std::clog << "Float | ";
+                std::clog << table_[i][1].str_ << " -> " << table_[i][col_num_].str_;
+            }
+            else
+            {
+                std::clog << "R" + std::to_string(i) << " | ";
+                if (table_[i][1].type_ == String) std::clog << "String | ";
+                if (table_[i][1].type_ == Int) std::clog << "Int | ";
+                if (table_[i][1].type_ == Float) std::clog << "Float | ";
+                std::clog << table_[i][1].str_ << " -> " << table_[i][col_num_].str_;
+            }
+
+            if (!table_[i][0].out_ok_) std::clog << " (No output)";
+            std::clog << std::endl;
+        }
+        std::clog << "============\n";
     }
-    std::clog << "============\n";
     return;
 }
 
 int gctl::dsv_io::name_index(std::string name, bool iter_row)
 {
+    // 拾取行号或列号 格式为R<id>和C<id>
+    std::smatch ret;
+    std::regex patr("R(\\d*)"), patc("C(\\d*)");
+    
     if (iter_row)
     {
-        if (thead_ != RowHead && thead_ != BothHead)
-		{
-			throw std::runtime_error("[gctl::dsv_io] The table is initialized with no row names.");
-		}
-
-        for (size_t i = 0; i < row_num_; i++)
+        for (size_t i = 1; i <= row_num_; i++)
 		{
 			if (table_[i][0].str_ == name) return i;
         }
 
-        throw gctl::runtime_error("[gctl::dsv_io] No row found by the input name: " + name);
-		return 0;
+        if (regex_search(name, ret, patr))
+        {
+            int r = atoi(std::string(ret[1]).c_str());
+            if (r >= 1 && r <= row_num_) return r;
+            else return -1;
+        }
+
+		return -1;
     }
     else
     {
-        if (thead_ != ColumnHead && thead_ != BothHead)
-		{
-			throw std::runtime_error("[gctl::dsv_io] The table is initialized with no column names.");
-		}
-
-        for (size_t i = 0; i < col_num_; i++)
+        for (size_t i = 1; i <= col_num_; i++)
 		{
             if (table_[0][i].str_ == name) return i;
         }
 
-        throw gctl::runtime_error("[gctl::dsv_io] No column found by the input name: " + name);
-		return 0;
+        if (regex_search(name, ret, patc))
+        {
+            int c = atoi(std::string(ret[1]).c_str());
+            if (c >= 1 && c <= col_num_) return c;
+            else return -1;
+        }
+
+		return -1;
     }
 }
 
+void gctl::dsv_io::column_output(int idx, switch_type_e s)
+{
+    if (idx > col_num_ || idx <= 0)
+    {
+        throw std::runtime_error("[gctl::dsv_io] Invalid column index.");
+    }
+
+    for (size_t i = 0; i <= row_num_; i++)
+    {
+        if (s == Enable) table_[i][idx].out_ok_ = true;
+        else table_[i][idx].out_ok_ = false;
+    }
+    return;
+}
+
+void gctl::dsv_io::column_output(std::string name, switch_type_e s)
+{
+    column_output(name_index(name), s);
+    return;
+}
+
+void gctl::dsv_io::row_output(int idx, switch_type_e s)
+{
+    if (idx > row_num_ || idx <= 0)
+    {
+        throw std::runtime_error("[gctl::dsv_io] Invalid row index.");
+    }
+
+    for (size_t i = 0; i <= col_num_; i++)
+    {
+        if (s == Enable) table_[idx][i].out_ok_ = true;
+        else table_[idx][i].out_ok_ = false;
+    }
+    return;
+}
+
+void gctl::dsv_io::row_output(std::string name, switch_type_e s)
+{
+    row_output(name_index(name), s);
+    return;
+}
+
+void gctl::dsv_io::add_column(std::string name)
+{
+    table_cell empty_cell;
+    for (size_t i = 0; i < table_.size(); i++)
+    {
+        table_[i].push_back(empty_cell);
+    }
+
+    table_[0].back().str_ = name;
+    col_num_++;
+    return;
+}
+
+void gctl::dsv_io::add_column(int idx, std::string name)
+{
+    table_cell empty_cell;
+    if (idx <= 0)
+    {
+        for (size_t i = 0; i < table_.size(); i++)
+        {
+            table_[i].push_back(empty_cell);
+        }
+
+        table_[0].back().str_ = name;
+        col_num_++;
+    }
+    else
+    {
+        for (size_t i = 0; i < table_.size(); i++)
+        {
+            table_[i].insert(table_[i].begin() + idx, empty_cell);
+        }
+
+        table_[0][idx].str_ = name;
+        col_num_++;
+    }
+    return;
+}
+
+void gctl::dsv_io::add_column(std::string id_name, std::string name)
+{
+    add_column(name_index(id_name), name);
+    return;
+}
+
+void gctl::dsv_io::add_row(std::string name)
+{
+    std::vector<table_cell> empty_line;
+    table_.push_back(empty_line);
+    table_.back().resize(col_num_ + 1);
+    table_.back().front().str_ = name;
+    row_num_++;
+    return;
+}
+
+void gctl::dsv_io::add_row(int idx, std::string name)
+{
+    std::vector<table_cell> empty_line;
+    if (idx <= 0)
+    {
+        table_.push_back(empty_line);
+        table_.back().resize(col_num_ + 1);
+        table_.back().front().str_ = name;
+        row_num_++;
+    }
+    else
+    {
+        table_.insert(table_.begin() + idx, empty_line);
+        table_[idx].resize(col_num_ + 1);
+        table_[idx].front().str_ = name;
+        row_num_++;
+    }
+    return;
+}
+
+void gctl::dsv_io::add_row(std::string id_name, std::string name)
+{
+    add_row(name_index(id_name), name);
+    return;
+}
+
+void gctl::dsv_io::filt_column(std::string cnd_str, std::string cnd_col, 
+	const std::vector<std::string> &out_col, dsv_io &out_table)
+{
+    int idx = name_index(cnd_col);
+    if (idx < 0) throw std::runtime_error("[gctl::dsv_io::] Invalid column index or name.");
+
+    array<int> odx;
+    bool out_row = false;
+    if (out_col.empty()) out_row = true;
+    else
+    {
+        odx.resize(out_col.size());
+        for (size_t i = 0; i < out_col.size(); i++)
+        {
+            odx[i] = name_index(out_col[i]);
+            if (odx[i] < 0) throw std::runtime_error("[gctl::dsv_io::] Invalid column index or name.");
+        }
+    }
+
+    std::smatch ret;
+    std::regex pat(cnd_str);
+    std::vector<std::string> str_line, row_names;
+    std::vector<std::vector<std::string> > str_table; 
+
+    for (size_t i = 1; i <= row_num_; i++)
+    {
+        if (regex_search(table_[i][idx].str_, ret, pat))
+        {
+            if (out_row)
+            {
+                str_line.clear();
+
+                for (size_t j = 1; j <= col_num_; j++)
+                {
+                    str_line.push_back(table_[i][j].str_);
+                }
+                
+                str_table.push_back(str_line);
+            }
+            else
+            {
+                str_line.clear();
+                str_line.push_back(table_[i][idx].str_);
+                
+                for (size_t j = 0; j < odx.size(); j++)
+                {
+                    str_line.push_back(table_[i][odx[j]].str_);
+                }
+                
+                str_table.push_back(str_line);
+            }
+
+            row_names.push_back(table_[i][0].str_);
+        }
+    }
+
+    out_table.init_table(str_table);
+
+    std::vector<std::string> io_col;
+    if (out_row)
+    {
+        get_column_names(io_col);
+        out_table.cell(table_[0][0].str_, 0, 0);
+    }
+    else
+    {
+        io_col.push_back(cnd_col);
+
+        for (size_t j = 0; j < odx.size(); j++)
+        {
+            io_col.push_back(out_col[j]);
+        }
+    }
+
+    out_table.set_column_names(io_col);
+    out_table.set_row_names(row_names, table_[0][0].str_);
+
+    destroy_vector(row_names);
+    destroy_vector(io_col);
+    destroy_vector(str_line);
+    destroy_vector(str_table);
+    return;
+}
+
+void gctl::dsv_io::filt_column(rowbool_func_t func, const std::vector<std::string> &out_col, dsv_io &out_table)
+{
+    array<int> odx;
+    bool out_row = false;
+    if (out_col.empty()) out_row = true;
+    else
+    {
+        odx.resize(out_col.size());
+        for (size_t i = 0; i < out_col.size(); i++)
+        {
+            odx[i] = name_index(out_col[i]);
+            if (odx[i] < 0) throw std::runtime_error("[gctl::dsv_io::] Invalid column index or name.");
+        }
+    }
+
+    std::vector<std::string> str_line, row_names;
+    std::vector<std::vector<std::string> > str_table; 
+
+    for (size_t i = 1; i <= row_num_; i++)
+    {
+        if (func(table_[i]))
+        {
+            if (out_row)
+            {
+                str_line.clear();
+
+                for (size_t j = 1; j <= col_num_; j++)
+                {
+                    str_line.push_back(table_[i][j].str_);
+                }
+                
+                str_table.push_back(str_line);
+            }
+            else
+            {
+                str_line.clear();
+                
+                for (size_t j = 0; j < odx.size(); j++)
+                {
+                    str_line.push_back(table_[i][odx[j]].str_);
+                }
+                
+                str_table.push_back(str_line);
+            }
+
+            row_names.push_back(table_[i][0].str_);
+        }
+    }
+
+    out_table.init_table(str_table);
+
+    std::vector<std::string> io_col;
+    if (out_row)
+    {
+        get_column_names(io_col);
+        out_table.cell(table_[0][0].str_, 0, 0);
+    }
+    else
+    {
+        for (size_t j = 0; j < odx.size(); j++)
+        {
+            io_col.push_back(out_col[j]);
+        }
+    }
+
+    out_table.set_column_names(io_col);
+    out_table.set_row_names(row_names, table_[0][0].str_);
+
+    destroy_vector(row_names);
+    destroy_vector(io_col);
+    destroy_vector(str_line);
+    destroy_vector(str_table);
+    return;
+}
+
+#ifdef GCTL_EXPRTK
+
+void gctl::dsv_io::cal_column(std::string expr_str, const std::vector<std::string> &col_list, int p)
+{
+    array<int> idx(col_list.size());
+    for (size_t i = 0; i < col_list.size(); i++)
+    {
+        idx[i] = name_index(col_list[i]);
+
+        if (idx[i] < 0) throw std::runtime_error("[gctl::dsv_io::] Invalid column index or name.");
+
+        if (table_[0][idx[i]].type_ != Int && table_[0][idx[i]].type_ != Float)
+        {
+            throw std::runtime_error("[gctl::dsv_io] Invalid column type for numerical calculating.");
+        }
+    }
+    
+    exprtk::symbol_table<double> symbol_table;
+	array<double> var(col_list.size());
+
+    for (size_t i = 0; i < var.size(); i++)
+	{
+		symbol_table.add_variable(col_list[i], var[i]);
+	}
+
+    exprtk::expression<double> expression;
+	expression.register_symbol_table(symbol_table);
+
+	exprtk::parser<double> parser;
+	if (!parser.compile(expr_str, expression))
+    {
+        throw std::runtime_error("[gctl::dsv_io] Fail to compile the math expression.");
+    }
+
+    for (size_t i = 1; i <= row_num_; i++)
+    {
+        // Remeber we put the output in the first element
+        for (size_t j = 1; j < var.size(); j++)
+        {
+            var[j] = table_[i][idx[j]].value<double>();
+        }
+
+        var[0] = expression.value();
+        table_[i][idx[0]].value(var[0], p);
+    }
+    return;
+}
+
+void gctl::dsv_io::filt_column(std::string cnd_str, const std::vector<std::string> &cnd_col, 
+	const std::vector<std::string> &out_col, dsv_io& out_table)
+{
+    array<int> idx(cnd_col.size());
+    for (size_t i = 0; i < cnd_col.size(); i++)
+    {
+        idx[i] = name_index(cnd_col[i]);
+
+        if (idx[i] < 0) throw std::runtime_error("[gctl::dsv_io::] Invalid column index or name.");
+
+        if (table_[0][idx[i]].type_ != Int && table_[0][idx[i]].type_ != Float)
+        {
+            throw std::runtime_error("[gctl::dsv_io] Invalid column type for numerical calculating.");
+        }
+    }
+
+    array<int> odx;
+    bool out_row = false;
+    if (out_col.empty()) out_row = true;
+    else
+    {
+        odx.resize(out_col.size());
+        for (size_t i = 0; i < out_col.size(); i++)
+        {
+            odx[i] = name_index(out_col[i]);
+            if (odx[i] < 0) throw std::runtime_error("[gctl::dsv_io::] Invalid column index or name.");
+        }
+    }
+    
+    exprtk::symbol_table<double> symbol_table;
+	array<double> var(cnd_col.size());
+
+    for (size_t i = 0; i < var.size(); i++)
+	{
+        symbol_table.add_variable(cnd_col[i], var[i]);
+	}
+
+    exprtk::expression<double> expression;
+	expression.register_symbol_table(symbol_table);
+
+	exprtk::parser<double> parser;
+	if (!parser.compile(cnd_str, expression))
+    {
+        throw std::runtime_error("[gctl::dsv_io] Fail to compile the math expression.");
+    }   
+
+    std::vector<std::string> str_line, row_names;
+    std::vector<std::vector<std::string> > str_table; 
+
+    for (size_t i = 1; i <= row_num_; i++)
+    {
+        for (size_t j = 0; j < var.size(); j++)
+        {
+            var[j] = table_[i][idx[j]].value<double>();
+        }
+
+        if (expression.value() > 0.5) // return 1 if matched or 0 if dismatched
+        {
+            if (out_row)
+            {
+                str_line.clear();
+
+                for (size_t j = 1; j <= col_num_; j++)
+                {
+                    str_line.push_back(table_[i][j].str_);
+                }
+                
+                str_table.push_back(str_line);
+            }
+            else
+            {
+                str_line.clear();
+                for (size_t j = 0; j < idx.size(); j++)
+                {
+                    str_line.push_back(table_[i][idx[j]].str_);
+                }
+                
+                for (size_t j = 0; j < odx.size(); j++)
+                {
+                    str_line.push_back(table_[i][odx[j]].str_);
+                }
+                
+                str_table.push_back(str_line);
+            }
+
+            row_names.push_back(table_[i][0].str_);
+        }
+    }
+
+    out_table.init_table(str_table);
+
+    std::vector<std::string> io_col;
+    if (out_row)
+    {
+        get_column_names(io_col);
+        out_table.cell(table_[0][0].str_, 0, 0);
+    }
+    else
+    {
+        for (size_t j = 0; j < idx.size(); j++)
+        {
+            io_col.push_back(cnd_col[j]);
+        }
+
+        for (size_t j = 0; j < odx.size(); j++)
+        {
+            io_col.push_back(out_col[j]);
+        }
+    }
+
+    out_table.set_column_names(io_col);
+    out_table.set_row_names(row_names, table_[0][0].str_);
+
+    destroy_vector(row_names);
+    destroy_vector(io_col);
+    destroy_vector(str_line);
+    destroy_vector(str_table);
+    return;
+}
+
+#endif // GCTL_EXPRTK
+
 gctl::geodsv_io::geodsv_io(){}
 
 gctl::geodsv_io::~geodsv_io(){}
@@ -329,130 +935,179 @@ gctl::geodsv_io::geodsv_io(std::string filename, std::string file_exten, table_h
 	head_num_ = 0;
     row_num_ = 0;
     col_num_ = 0;
-    thead_ = ColumnHead;
 
     if (file_exten == ".csv") load_csv(filename, t);
     else load_text(filename, file_exten, t);
 }
 
-void gctl::geodsv_io::fill_column_point2dc(int xid, int yid, const array<point2dc> &data, int p)
+void gctl::geodsv_io::fill_column_point2dc(const array<point2dc> &data, int xid, int yid, int p)
 {
-    if (xid >= col_num_ || yid >= col_num_ || xid == yid)
+    if (xid > col_num_ || yid > col_num_ || xid == yid || xid <= 0 || yid <= 0)
     {
         throw std::runtime_error("[gctl::geodsv_io] Invalid column index.");
     }
 
-    int st = 0;
-	if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
-
     std::stringstream ss;
     std::string s;
-    for (size_t i = 0; i < std::min(row_num_ - st, (int) data.size()); i++)
+    for (size_t i = 1; i <= std::min(row_num_, (int) data.size()); i++)
     {
         ss.clear();
-        ss << data[i].x;
+        ss << data[i - 1].x;
         ss >> s;
-        table_[i + st][xid].str_ = s;
+        table_[i][xid].str_ = s;
 
         ss.clear();
-        ss << data[i].y;
+        ss << data[i - 1].y;
         ss >> s;
-        table_[i + st][yid].str_ = s;
+        table_[i][yid].str_ = s;
     }
     return;
 }
 
-void gctl::geodsv_io::fill_column_point2dc(std::string xname, std::string yname, const array<point2dc> &data, int p)
+void gctl::geodsv_io::fill_column_point2dc(const array<point2dc> &data, std::string xname, std::string yname, int p)
 {
-    fill_column_point2dc(name_index(xname, false), name_index(yname, false), data, p);
+    fill_column_point2dc(data, name_index(xname, false), name_index(yname, false), p);
     return;
 }
 
-void gctl::geodsv_io::fill_column_point3dc(int xid, int yid, int zid, const array<point3dc> &data, int p)
+void gctl::geodsv_io::fill_column_point3dc(const array<point3dc> &data, int xid, int yid, int zid, int p)
 {
-    if (xid >= col_num_ || yid >= col_num_ || zid >= col_num_ || xid == yid || yid == zid || xid == zid)
+    if (xid > col_num_ || yid > col_num_ || zid > col_num_ || xid == yid || yid == zid || xid == zid
+        || xid <= 0 || yid <= 0 || zid <= 0)
     {
         throw std::runtime_error("[gctl::geodsv_io] Invalid column index.");
     }
 
-    int st = 0;
-	if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
-
     std::stringstream ss;
     std::string s;
-    for (size_t i = 0; i < std::min(row_num_ - st, (int) data.size()); i++)
+    for (size_t i = 1; i < std::min(row_num_, (int) data.size()); i++)
     {
         ss.clear();
-        ss << data[i].x;
+        ss << data[i - 1].x;
         ss >> s;
-        table_[i + st][xid].str_ = s;
+        table_[i][xid].str_ = s;
 
         ss.clear();
-        ss << data[i].y;
+        ss << data[i - 1].y;
         ss >> s;
-        table_[i + st][yid].str_ = s;
+        table_[i][yid].str_ = s;
 
         ss.clear();
-        ss << data[i].z;
+        ss << data[i - 1].z;
         ss >> s;
-        table_[i + st][zid].str_ = s;
+        table_[i][zid].str_ = s;
     }
     return;
 }
 
-void gctl::geodsv_io::fill_column_point3dc(std::string xname, std::string yname, std::string zname, const array<point3dc> &data, int p)
+void gctl::geodsv_io::fill_column_point3dc(const array<point3dc> &data, std::string xname, std::string yname, std::string zname, int p)
 {
-    fill_column_point3dc(name_index(xname, false), name_index(yname, false), name_index(zname, false), data, p);
+    fill_column_point3dc(data, name_index(xname, false), name_index(yname, false), name_index(zname, false), p);
     return;
 }
 
-void gctl::geodsv_io::get_column_point2dc(int xid, int yid, array<point2dc> &data)
+void gctl::geodsv_io::fill_column_point3ds(const array<point3ds> &data, int rid, int pid, int tid, int p)
 {
-    if (xid >= col_num_ || yid >= col_num_ || xid == yid)
+    if (rid > col_num_ || pid > col_num_ || tid > col_num_ || rid == pid || pid == tid || tid == rid
+        || rid <= 0 || pid <= 0 || tid <= 0)
     {
         throw std::runtime_error("[gctl::geodsv_io] Invalid column index.");
     }
 
-    int st = 0;
-	if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
-
-    data.resize(row_num_ - st);
-    for (size_t i = st; i < row_num_; i++)
+    std::stringstream ss;
+    std::string s;
+    for (size_t i = 1; i < std::min(row_num_, (int) data.size()); i++)
     {
-        data[i - st].x = table_[i][xid].value<double>();
-        data[i - st].y = table_[i][yid].value<double>();
+        ss.clear();
+        ss << data[i - 1].rad;
+        ss >> s;
+        table_[i][rid].str_ = s;
+
+        ss.clear();
+        ss << data[i - 1].lon;
+        ss >> s;
+        table_[i][pid].str_ = s;
+
+        ss.clear();
+        ss << data[i - 1].lat;
+        ss >> s;
+        table_[i][tid].str_ = s;
     }
     return;
 }
 
-void gctl::geodsv_io::get_column_point2dc(std::string xname, std::string yname, array<point2dc> &data)
+void gctl::geodsv_io::fill_column_point3ds(const array<point3ds> &data, std::string rname, std::string pname, std::string tname, int p)
 {
-    get_column_point2dc(name_index(xname, false), name_index(yname, false), data);
+    fill_column_point3ds(data, name_index(rname, false), name_index(pname, false), name_index(tname, false), p);
     return;
 }
 
-void gctl::geodsv_io::get_column_point3dc(int xid, int yid, int zid, array<point3dc> &data)
+void gctl::geodsv_io::get_column_point2dc(array<point2dc> &data, int xid, int yid)
 {
-    if (xid >= col_num_ || yid >= col_num_ || zid >= col_num_ || xid == yid || yid == zid || xid == zid)
+    if (xid > col_num_ || yid > col_num_ || xid == yid || xid <= 0 || yid <= 0)
     {
         throw std::runtime_error("[gctl::geodsv_io] Invalid column index.");
     }
 
-    int st = 0;
-	if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
-
-    data.resize(row_num_ - st);
-    for (size_t i = st; i < row_num_; i++)
+    data.resize(row_num_);
+    for (size_t i = 1; i <= row_num_; i++)
     {
-        data[i - st].x = table_[i][xid].value<double>();
-        data[i - st].y = table_[i][yid].value<double>();
-        data[i - st].z = table_[i][zid].value<double>();
+        data[i - 1].x = table_[i][xid].value<double>();
+        data[i - 1].y = table_[i][yid].value<double>();
     }
     return;
 }
 
-void gctl::geodsv_io::get_column_point3dc(std::string xname, std::string yname, std::string zname, array<point3dc> &data)
+void gctl::geodsv_io::get_column_point2dc(array<point2dc> &data, std::string xname, std::string yname)
 {
-    get_column_point3dc(name_index(xname, false), name_index(yname, false), name_index(zname, false), data);
+    get_column_point2dc(data, name_index(xname, false), name_index(yname, false));
+    return;
+}
+
+void gctl::geodsv_io::get_column_point3dc(array<point3dc> &data, int xid, int yid, int zid)
+{
+    if (xid > col_num_ || yid > col_num_ || zid > col_num_ || xid == yid || yid == zid || xid == zid
+        || xid <= 0 || yid <= 0 || zid <= 0)
+    {
+        throw std::runtime_error("[gctl::geodsv_io] Invalid column index.");
+    }
+
+    data.resize(row_num_);
+    for (size_t i = 1; i <= row_num_; i++)
+    {
+        data[i - 1].x = table_[i][xid].value<double>();
+        data[i - 1].y = table_[i][yid].value<double>();
+        data[i - 1].z = table_[i][zid].value<double>();
+    }
+    return;
+}
+
+void gctl::geodsv_io::get_column_point3dc(array<point3dc> &data, std::string xname, std::string yname, std::string zname)
+{
+    get_column_point3dc(data, name_index(xname, false), name_index(yname, false), name_index(zname, false));
+    return;
+}
+
+void gctl::geodsv_io::get_column_point3ds(array<point3ds> &data, int rid, int pid, int tid)
+{
+    if (rid > col_num_ || pid > col_num_ || tid > col_num_ || rid == pid || pid == tid || tid == rid
+        || rid <= 0 || pid <= 0 || tid <= 0)
+    {
+        throw std::runtime_error("[gctl::geodsv_io] Invalid column index.");
+    }
+
+    data.resize(row_num_);
+    for (size_t i = 1; i <= row_num_; i++)
+    {
+        data[i - 1].rad = table_[i][rid].value<double>();
+        data[i - 1].lon = table_[i][pid].value<double>();
+        data[i - 1].lat = table_[i][tid].value<double>();
+    }
+    return;
+}
+
+void gctl::geodsv_io::get_column_point3ds(array<point3ds> &data, std::string rname, std::string pname, std::string tname)
+{
+    get_column_point3ds(data, name_index(rname, false), name_index(pname, false), name_index(tname, false));
     return;
 }
\ No newline at end of file
diff --git a/lib/io/dsv_io.h b/lib/io/dsv_io.h
index 85692c5..c6f2fba 100644
--- a/lib/io/dsv_io.h
+++ b/lib/io/dsv_io.h
@@ -28,15 +28,37 @@
 #ifndef _GCTL_DSV_IO_H
 #define _GCTL_DSV_IO_H
 
+#include "../gctl_config.h"
 #include "../core.h"
 #include "../utility.h"
 #include "../geometry.h"
+#include "regex.h"
+
+#ifdef GCTL_EXPRTK
+#include "exprtk.hpp"
+#endif // GCTL_EXPRTK
 
 namespace gctl
 {
+	enum cell_type_e
+	{
+		String,
+		Int,
+		Float,
+	};
+
 	struct table_cell
 	{
-		std::string str_;
+		std::string str_; // 单元格的内容 统一保存为字符串
+		cell_type_e type_; // 类型字符串
+		bool out_ok_; // 是否可输出到文件
+
+		table_cell()
+		{
+			str_ = "";
+			type_ = Float;
+			out_ok_ = true;
+		}
 		
 		template <typename T> T value()
 		{
@@ -52,6 +74,18 @@ namespace gctl
 
 		template <typename T> void value(const T &in, int p = 6)
 		{
+			// 单元被赋值时使用的类型
+			const std::type_info &tinfo = typeid(T);
+
+			std::smatch ret;
+			std::regex pat("basic_string");
+			
+			std::string t_str = tinfo.name();
+			if (regex_search(t_str, ret, pat)) type_ = String;
+			else if (t_str == "i") type_ = Int;
+			else if (t_str == "f") type_ = Float;
+			else if (t_str == "d") type_ = Float;
+
 			// 对于double类型 可以设置转换的有效数字位数（精度）
 			if constexpr (std::is_same<T, double>::value)
 			{
@@ -86,21 +120,21 @@ namespace gctl
 	 * 2. 以'#!'开始的行均为标记行，标识符可由用户指定；
 	 * 3. 文本开始可以包含n行头信息；
 	 * 4. 数据体为一个row*col大小的表格；
-	 * 5. 数据体可以包含一列行名称与列名称。
-	 * 
+	 * 5. 数据表格文件可以额外包含一列行名称与列名称；
+	 * 6. 如论文件内是否包含行头或列头，均可使用内置的行名称R<id>或列名称C<id>指定相应的行或列
 	 */
     class dsv_io
 	{
 	protected:
+		// 文件名
 		std::string file_;
-		table_headtype_e thead_;
-        // 头信息行数 表格行数 表格列数
+        // 头信息行数 表格行数（不包括表头） 表格列数（不包括表头）
 		int head_num_, row_num_, col_num_;
 		// 注释行起始符 标记行起始符 分割符
 		char att_sym_, tag_sym_, deli_sym_;
 		// 头信息行 注释行 标记行
 		std::vector<std::string> heads_, annotates_, tags_;
-		// 内容表格
+		// 内容表格（大小为row_num_+1 * col_num_+1）
 		std::vector<std::vector<table_cell> > table_;
 
 	public:
@@ -121,9 +155,72 @@ namespace gctl
 		 * 
 		 * @param filename 文件名
 		 * @param file_exten 文件扩展名
+		 * @param t 表格是否有行和列名称
 		 */
 		dsv_io(std::string filename, std::string file_exten = ".txt", table_headtype_e t = NoHead);
 
+		/**
+         * @brief 清理字符串向量对象
+         * 
+         */
+		void clear();
+
+		/**
+		 * @brief 返回头信息行数
+		 * 
+		 * @return 行数
+		 */
+		int head_number(){return head_num_;}
+
+		/**
+		 * @brief 返回数据行数
+		 * 
+		 * @return 行数
+		 */
+		int row_number(){return row_num_;}
+
+		/**
+		 * @brief 返回数据列数
+		 * 
+		 * @return 列数
+		 */
+		int col_number(){return col_num_;}
+
+		/**
+		 * @brief 返回头信息
+		 * 
+		 * @return 头信息
+		 */
+		const std::vector<std::string>& get_head_records(){return heads_;}
+
+		/**
+		 * @brief 返回注释行
+		 * 
+		 * @return 注释行
+		 */
+		const std::vector<std::string>& get_annotoations(){return annotates_;}
+
+		/**
+		 * @brief 返回标记行
+		 * 
+		 * @return 标记
+		 */
+		const std::vector<std::string>& get_tags(){return tags_;}
+
+		/**
+		 * @brief 获取行名称
+		 * 
+		 * @param names 名称
+		 */
+		void get_row_names(std::vector<std::string> &names);
+
+		/**
+		 * @brief 获取列名称
+		 * 
+		 * @param names 名称
+		 */
+		void get_column_names(std::vector<std::string> &names);
+
 		/**
 		 * @brief 设置列分隔符
 		 * 
@@ -152,80 +249,79 @@ namespace gctl
 		 */
 		void set_tag_symbol(char tag_sym){tag_sym_ = tag_sym;}
 
-		/**
-		 * @brief 返回头信息行数
-		 * 
-		 * @return 行数
-		 */
-		int head_number(){return head_num_;}
-
-		/**
-		 * @brief 返回行数
-		 * 
-		 * @return 行数
-		 */
-		int row_number(){return row_num_;}
-
-		/**
-		 * @brief 返回列数
-		 * 
-		 * @return 列数
-		 */
-		int col_number(){return col_num_;}
-
-		/**
-		 * @brief 返回头信息
-		 * 
-		 * @return 头信息
-		 */
-		const std::vector<std::string>& get_head_records(){return heads_;}
-
-		/**
-		 * @brief 返回注释行
-		 * 
-		 * @return 注释行
-		 */
-		const std::vector<std::string>& get_annotoations(){return annotates_;}
-
-		/**
-		 * @brief 返回标记行
-		 * 
-		 * @return 标记
-		 */
-		const std::vector<std::string>& get_tags(){return tags_;}
-
 		/**
 		 * @brief 设置头信息
 		 * 
 		 * @param heads 头信息
 		 */
-		void set_head_records(const std::vector<std::string> &heads);
+		void set_head_records(const std::vector<std::string> &heads){heads_ = heads; head_num_ = heads_.size();}
 
 		/**
 		 * @brief 设置注释
 		 * 
 		 * @param att 注释
 		 */
-		void set_annotoations(const std::vector<std::string> &att);
+		void set_annotoations(const std::vector<std::string> &att){annotates_ = att;}
 
 		/**
 		 * @brief 设置标记
 		 * 
 		 * @param tags 标记
 		 */
-		void set_tags(const std::vector<std::string> &tags);
+		void set_tags(const std::vector<std::string> &tags){tags_ = tags;}
 
-        /**
-         * @brief 清理字符串向量对象
-         * 
-         */
-		void clear();
+		/**
+		 * @brief 设置行名称
+		 * 
+		 * @param names 名称
+		 */
+		void set_row_names(const std::vector<std::string> &names, std::string corner_name = "row-idx");
+
+		/**
+		 * @brief 设置列名称
+		 * 
+		 * @param names 名称
+		 */
+		void set_column_names(const std::vector<std::string> &names);
+
+		/**
+		 * @brief 设置行类型
+		 * 
+		 * @param t 类型名称 String|Float|Int
+		 * @param idx 行索引
+		 */
+		void set_row_type(cell_type_e t, int idx);
+
+		/**
+		 * @brief 设置行类型
+		 * 
+		 * @param t 类型名称 String|Float|Int
+		 * @param name 行名称
+		 */
+		void set_row_type(cell_type_e t, std::string name);
+
+		/**
+		 * @brief 设置列类型
+		 * 
+		 * @param t 类型名称 String|Float|Int
+		 * @param idx 列索引
+		 */
+		void set_column_type(cell_type_e t, int idx);
+
+		/**
+		 * @brief 设置列类型
+		 * 
+		 * @param t 类型名称 String|Float|Int
+		 * @param name 列名称
+		 */
+		void set_column_type(cell_type_e t, std::string name);
 
 		/**
 		 * @brief 读入文本文件
 		 * 
 		 * @param filename 文件名
 		 * @param file_exten 文件扩展名
+		 * @param t 表格是否有行和列名称
 		 */
 		void load_text(std::string filename, std::string file_exten = ".txt", table_headtype_e t = NoHead);
 
@@ -254,34 +350,176 @@ namespace gctl
 		/**
 		 * @brief 初始化表格
 		 * 
-		 * @param row 行数
-		 * @param col 列数
+		 * @param row 数据行数
+		 * @param col 数据列数
 		 */
-		void init_table(int row, int col, table_headtype_e t = ColumnHead);
+		void init_table(int row, int col);
 
 		/**
 		 * @brief 返回表格信息
 		 * 
+		 * @param t 显示表格信息的类型
 		 */
-		void info();
+		void info(table_headtype_e t = ColumnHead);
 
 		/**
-		 * @brief 返回名称为name的行或列的索引
+		 * @brief 返回名称为name和R<id>和C<id>的行或列的索引
 		 * 
-		 * @param name 名称
-		 * @param iter_row 搜索行名称（默认为搜索列名称）
-		 * @return 索引
+		 * @param name 名称 可以是具体的名称（如有），或者是R<id>和C<id>
+		 * @param iter_row 搜索行名称（默认为搜索列名称），如果name参数为R<id>和C<id>则此参数无效
+		 * @return 索引 返回的索引（大于等于1 小于等于行数或列数）失败则返回-1
 		 */
 		int name_index(std::string name, bool iter_row = false);
 
+		/**
+		 * @brief 设置列输出。你仍然可以使用这些数据，它们只是不会被输出
+		 * 
+		 * @param idx 列索引 从1开始
+		 * @param s 设置输出类型
+		 */
+		void column_output(int idx, switch_type_e s = Disable);
+
+		/**
+		 * @brief 设置列输出。你仍然可以使用这些数据，它们只是不会被输出
+		 * 
+		 * @param name 列名称
+		 * @param s 设置输出类型
+		 */
+		void column_output(std::string name, switch_type_e s = Disable);
+
+		/**
+		 * @brief 设置行输出。你仍然可以使用这些数据，它们只是不会被输出
+		 * 
+		 * @param idx 行索引 从1开始
+		 * @param s 设置输出类型
+		 */
+		void row_output(int idx, switch_type_e s = Disable);
+
+		/**
+		 * @brief 设置行输出。你仍然可以使用这些数据，它们只是不会被输出
+		 * 
+		 * @param name 行名称
+		 * @param s 设置输出类型
+		 */
+		void row_output(std::string name, switch_type_e s = Disable);
+		
+		/**
+		 * @brief 在表格末尾添加一个空白列
+		 * 
+		 * @param name 设置列名称
+		 */
+		void add_column(std::string name = "");
+
+		/**
+		 * @brief 在索引为idx的列插入一个空白列
+		 * 
+		 * @param idx 列索引 小于等于0时将在表尾添加一列
+		 * @param name 设置列名称
+		 */
+		void add_column(int idx, std::string name = "");
+
+		/**
+		 * @brief 在名称为id_name的列插入一个空白列
+		 * 
+		 * @param id_name 索引列名称
+		 * @param name 设置列名称
+		 */
+		void add_column(std::string id_name, std::string name = "");
+
+		/**
+		 * @brief 在表格末尾添加一个空白行
+		 * 
+		 * @param name 设置行名称
+		 */
+		void add_row(std::string name = "");
+
+		/**
+		 * @brief 在索引为idx的列插入一个空白行
+		 * 
+		 * @param idx 行索引 小于等于0时将在表尾添加一行
+		 * @param name 设置行名称
+		 */
+		void add_row(int idx, std::string name = "");
+
+		/**
+		 * @brief 在名称为id_name的列插入一个空白行
+		 * 
+		 * @param id_name 索引行名称
+		 * @param name 设置行名称
+		 */
+		void add_row(std::string id_name, std::string name = "");
+
+		/**
+		 * @brief 按行过滤并返回符合条件的列数据
+		 * 
+		 * @param cnd_str 正则表达式
+		 * @param cnd_col 用于匹配正则表达式的列名称
+		 * @param out_col 输出的列索引列表（列表为空时则会输出所有列），正则表达式为真时即筛选这些行与列上对应的数据
+		 * @param out_table 输出的表格
+		 */
+		void filt_column(std::string cnd_str, std::string cnd_col, 
+			const std::vector<std::string> &out_col, dsv_io &out_table);
+
+		/**
+		 * @brief row operate function pointer
+		 * 
+		 */
+		typedef bool (*rowbool_func_t)(const std::vector<table_cell> &table_row);
+
+		/**
+		 * @brief  按行过滤并返回符合条件的列数据
+		 * 
+		 * @param func 处理行类容的布尔函数
+		 * @param out_col 输出的列索引列表（列表为空时则会输出所有列），正则表达式为真时即筛选这些行与列上对应的数据
+		 * @param out_table 输出的表格
+		 */
+		void filt_column(rowbool_func_t func, const std::vector<std::string> &out_col, dsv_io &out_table);
+
+#ifdef GCTL_EXPRTK
+
+		/**
+		 * @brief 使用现有的表格数据计算新的列数据。使用时需要提供计算表达式，例如：C3 := C1 + C2
+		 * 表示将C1与C2列数据的和保存到C3列，其中C<id>表示计算所使用数据的索引，你也可以使用具体的列名称。
+		 * 
+		 * @note  只有单元格类型为float和Int类型的列数据才能用于计算。计算由exprtk库完成，支持的表达式见其说明文档。
+		 * 
+		 * @param expr_str 计算表达式 如C3 := C1 + C2
+		 * @param col_list 列索引列表 如C3 C1 C2 （注意保存计算结果的列要放在开头）
+		 * @param p 浮点类数据保存时的有效数字位数
+		 */
+		void cal_column(std::string expr_str, const std::vector<std::string> &col_list, int p = 6);
+
+		/**
+		 * @brief 按行过滤并返回符合条件的列数据
+		 * 
+		 * @note  只有单元格类型为float和Int类型的列数据才能用于计算。计算由exprtk库完成，支持的表达式见其说明文档。
+		 * 因为没有使用strtk库的相关内容，所以并不支持对字符串与数字类型的混合条件判断。基于字符串的内容提取请使用其他函数。
+		 * 
+		 * @param cnd_str 条件表达式
+		 * @param cnd_col 用于条件表达式的列索引列表
+		 * @param out_col 输出的列索引列表（列表为空时则会输出所有列），即条件判断为真时即筛选这些行与列上对应的数据
+		 * @param out_table 输出的表格
+		 */
+		void filt_column(std::string cnd_str, const std::vector<std::string> &cnd_col, 
+			const std::vector<std::string> &out_col, dsv_io &out_table);
+
+#endif // GCTL_EXPRTK
+
+		/**
+		 * @brief 初始化表格
+		 * 
+		 * @param data 向量表格 每行元素个数必须相等（不包含行与列的名称）
+		 */
+		template <typename T> void init_table(const std::vector<std::vector<T> > &data, int p = 6);
+
 		/**
 		 * @brief 填充表格
 		 * 
 		 * @tparam T 数据类型
-		 * @param data 矩阵数据
+		 * @param data 矩阵数据 大小与表格一致
 		 * @param p 浮点类数据保存时的有效数字位数
 		 */
-		template <typename T> void fill_table(const matrix<T> &data, int p = 6);
+		template <typename T> void init_table(const matrix<T> &data, int p = 6);
 
 		/**
 		 * @brief 获取表格
@@ -295,11 +533,11 @@ namespace gctl
 		 * @brief 填充列
 		 * 
 		 * @tparam T 数据类型
-		 * @param idx 列索引
+		 * @param idx 列索引 从1开始
 		 * @param data 列数据
 		 * @param p 浮点类数据保存时的有效数字位数
 		 */
-		template <typename T> void fill_column(int idx, const array<T> &data, int p = 6);
+		template <typename T> void fill_column(const array<T> &data, int idx, int p = 6);
 
 		/**
 		 * @brief 填充列
@@ -309,17 +547,17 @@ namespace gctl
 		 * @param data 列数据
 		 * @param p 浮点类数据保存时的有效数字位数
 		 */
-		template <typename T> void fill_column(std::string name, const array<T> &data, int p = 6);
+		template <typename T> void fill_column(const array<T> &data, std::string name, int p = 6);
 
 		/**
 		 * @brief 填充行
 		 * 
 		 * @tparam T 数据类型
-		 * @param idx 行索引
+		 * @param idx 行索引 从1开始
 		 * @param data 行数据
 		 * @param p 浮点类数据保存时的有效数字位数
 		 */
-		template <typename T> void fill_row(int idx, const array<T> &data, int p = 6);
+		template <typename T> void fill_row(const array<T> &data, int idx, int p = 6);
 
 		/**
 		 * @brief 填充行
@@ -329,16 +567,16 @@ namespace gctl
 		 * @param data 行数据
 		 * @param p 浮点类数据保存时的有效数字位数
 		 */
-		template <typename T> void fill_row(std::string name, const array<T> &data, int p = 6);
+		template <typename T> void fill_row(const array<T> &data, std::string name, int p = 6);
 
 		/**
 		 * @brief 获取列数据
 		 * 
 		 * @tparam T 数据类型
-		 * @param idx 列索引
+		 * @param idx 列索引 从1开始
 		 * @param data 列数据
 		 */
-		template <typename T> void get_column(int idx, array<T> &data);
+		template <typename T> void get_column(array<T> &data, int idx);
 
 		/**
 		 * @brief 获取列数据
@@ -347,16 +585,16 @@ namespace gctl
 		 * @param name 列名称
 		 * @param data 列数据
 		 */
-		template <typename T> void get_column(std::string name, array<T> &data);
+		template <typename T> void get_column(array<T> &data, std::string name);
 		
 		/**
 		 * @brief 获取行数据
 		 * 
 		 * @tparam T 数据类型
-		 * @param idx 行索引
+		 * @param idx 行索引 从1开始
 		 * @param data 行数据
 		 */
-		template <typename T> void get_row(int idx, array<T> &data);
+		template <typename T> void get_row(array<T> &data, int idx);
 
 		/**
 		 * @brief 获取行数据
@@ -365,14 +603,14 @@ namespace gctl
 		 * @param name 行名称
 		 * @param data 行数据
 		 */
-		template <typename T> void get_row(std::string name, array<T> &data);
+		template <typename T> void get_row(array<T> &data, std::string name);
 		
 		/**
 		 * @brief 获取表格单元数据
 		 * 
 		 * @tparam T 数据类型
-		 * @param r 行号
-		 * @param c 列号
+		 * @param r 行号 从0开始（可以操作行或列名称）
+		 * @param c 列号 从0开始（可以操作行或列名称）
 		 * @return T 单元数据
 		 */
 		template <typename T> T cell(int r, int c){return table_[r][c].value<T>();}
@@ -381,28 +619,59 @@ namespace gctl
 		 * @brief 填充表格单元数据
 		 * 
 		 * @tparam T 数据类型
-		 * @param r 行号
-		 * @param c 列号
+		 * @param r 行号 从0开始（可以操作行或列名称）
+		 * @param c 列号 从0开始（可以操作行或列名称）
 		 * @param d 数据
 		 * @param p 浮点类数据保存时的有效数字位数
 		 */
-		template <typename T> void cell(int r, int c, T d, int p = 6){table_[r][c].value(d, p); return;}
+		template <typename T> void cell(T d, int r, int c, int p = 6){table_[r][c].value(d, p); return;}
 	};
 
 	template <typename T>
-	void dsv_io::fill_table(const matrix<T> &data, int p)
+	void dsv_io::init_table(const std::vector<std::vector<T> > &data, int p)
 	{
-		int st = 0;
-		if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
+		if (!table_.empty()) clear();
 
-		int ft = 0;
-		if (thead_ == RowHead || thead_ == BothHead) ft = 1;
+		row_num_ = data.size();
+		col_num_ = data[0].size();
 
-		for (size_t i = 0; i < std::min(row_num_ - st, (int) data.row_size()); i++)
+		// 初始的列头和行头均为空白
+		table_.resize(row_num_ + 1);
+		for (size_t i = 0; i < row_num_ + 1; i++)
 		{
-			for (size_t j = 0; j < std::min(col_num_ - ft, (int) data.col_size()); j++)
+			table_[i].resize(col_num_ + 1);
+		}
+
+		for (size_t i = 1; i <= row_num_; i++)
+		{
+			for (size_t j = 1; j <= col_num_; j++)
 			{
-				table_[i + st][j + ft].value(data[i][j], p);
+				table_[i][j].value(data[i - 1][j - 1], p);
+			}
+		}
+		return;
+	}
+
+	template <typename T>
+	void dsv_io::init_table(const matrix<T> &data, int p)
+	{
+		if (!table_.empty()) clear();
+
+		row_num_ = data.row_size();
+    	col_num_ = data.col_size();
+
+		// 初始的列头和行头均为空白
+		table_.resize(row_num_ + 1);
+		for (size_t i = 0; i < row_num_ + 1; i++)
+		{
+			table_[i].resize(col_num_ + 1);
+		}
+		
+		for (size_t i = 1; i <= row_num_; i++)
+		{
+			for (size_t j = 1; j <= col_num_; j++)
+			{
+				table_[i][j].value(data[i - 1][j - 1], p);
 			}
 		}
 		return;
@@ -411,122 +680,104 @@ namespace gctl
 	template <typename T>
 	void dsv_io::get_table(matrix<T> &data)
 	{
-		int st = 0;
-		if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
-
-		int ft = 0;
-		if (thead_ == RowHead || thead_ == BothHead) ft = 1;
-
-		data.resize(row_num_ - st, col_num_ - ft);
-		for (size_t i = st; i < row_num_; i++)
+		data.resize(row_num_, col_num_);
+		for (size_t i = 1; i <= row_num_; i++)
 		{
-			for (size_t j = ft; j < col_num_; j++)
+			for (size_t j = 1; j <= col_num_; j++)
 			{
-				data[i - st][j - ft] = table_[i][j].value<T>();
+				data[i -1][j - 1] = table_[i][j].value<T>();
 			}
 		}
 		return;
 	}
 
 	template <typename T>
-	void dsv_io::fill_column(int idx, const array<T> &data, int p)
+	void dsv_io::fill_column(const array<T> &data, int idx, int p)
 	{
-		if (idx >= col_num_)
-		{
-			throw std::runtime_error("[gctl::dsv_io] Invalid column index.");
-		}
-		
-		int st = 0;
-		if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
-		
-		for (size_t i = 0; i < std::min(row_num_ - st, (int) data.size()); i++)
-		{
-			table_[i + st][idx].value(data[i], p);
-		}
-		return;
-	}
-
-	template <typename T>
-	void dsv_io::fill_column(std::string name, const array<T> &data, int p)
-	{
-		fill_column(name_index(name, false), data, p);
-		return;
-	}
-
-	template <typename T>
-	void dsv_io::fill_row(int idx, const array<T> &data, int p)
-	{
-		if (idx >= row_num_)
-		{
-			throw std::runtime_error("[gctl::dsv_io] Invalid row index.");
-		}
-
-		int st = 0;
-		if (thead_ == RowHead || thead_ == BothHead) st = 1;
-
-		for (size_t i = 0; i < std::min(col_num_ - st, (int) data.size()); i++)
-		{
-			table_[idx][i + st].value(data[i], p);
-		}
-		return;
-	}
-
-	template <typename T>
-	void dsv_io::fill_row(std::string name, const array<T> &data, int p)
-	{
-		fill_row(name_index(name, true), data, p);
-		return;
-	}
-
-	template <typename T>
-	void dsv_io::get_column(int idx, array<T> &data)
-	{
-		if (idx >= col_num_)
+		if (idx > col_num_ || idx <= 0)
 		{
 			throw std::runtime_error("[gctl::dsv_io] Invalid column index.");
 		}
 
-		int st = 0;
-		if (thead_ == ColumnHead || thead_ == BothHead) st = 1;
-
-		data.resize(row_num_ - st);
-		for (size_t i = st; i < row_num_; i++)
+		for (size_t i = 1; i <= std::min(row_num_, (int) data.size()); i++)
 		{
-			data[i - st] = table_[i][idx].value<T>();
+			table_[i][idx].value(data[i - 1], p);
 		}
 		return;
 	}
 
 	template <typename T>
-	void dsv_io::get_column(std::string name, array<T> &data)
+	void dsv_io::fill_column(const array<T> &data, std::string name, int p)
 	{
-		get_column(name_index(name, false), data);
+		fill_column(data, name_index(name, false), p);
 		return;
 	}
 
 	template <typename T>
-	void dsv_io::get_row(int idx, array<T> &data)
+	void dsv_io::fill_row(const array<T> &data, int idx, int p)
 	{
-		if (idx >= row_num_)
+		if (idx > row_num_ || idx <= 0)
 		{
 			throw std::runtime_error("[gctl::dsv_io] Invalid row index.");
 		}
-		
-		int st = 0;
-		if (thead_ == RowHead || thead_ == BothHead) st = 1;
 
-		data.resize(col_num_ - st);
-		for (size_t i = st; i < col_num_; i++)
+		for (size_t i = 1; i <= std::min(col_num_, (int) data.size()); i++)
 		{
-			data[i - st] = table_[idx][i].value<T>();
+			table_[idx][i].value(data[i - 1], p);
 		}
 		return;
 	}
 
 	template <typename T>
-	void dsv_io::get_row(std::string name, array<T> &data)
+	void dsv_io::fill_row(const array<T> &data, std::string name, int p)
 	{
-		get_row(name_index(name, true), data);
+		fill_row(data, name_index(name, true), p);
+		return;
+	}
+
+	template <typename T>
+	void dsv_io::get_column(array<T> &data, int idx)
+	{
+		if (idx > col_num_ || idx <= 0)
+		{
+			throw std::runtime_error("[gctl::dsv_io] Invalid column index.");
+		}
+
+		data.resize(row_num_);
+		for (size_t i = 1; i <= row_num_; i++)
+		{
+			data[i - 1] = table_[i][idx].value<T>();
+		}
+		return;
+	}
+
+	template <typename T>
+	void dsv_io::get_column(array<T> &data, std::string name)
+	{
+		get_column(data, name_index(name, false));
+		return;
+	}
+
+	template <typename T>
+	void dsv_io::get_row(array<T> &data, int idx)
+	{
+		if (idx > row_num_ || idx <= 0)
+		{
+			throw std::runtime_error("[gctl::dsv_io] Invalid row index.");
+		}
+
+		data.resize(col_num_);
+		for (size_t i = 1; i <= col_num_; i++)
+		{
+			data[i - 1] = table_[idx][i].value<T>();
+		}
+		return;
+	}
+
+	template <typename T>
+	void dsv_io::get_row(array<T> &data, std::string name)
+	{
+		get_row(data, name_index(name, true));
 		return;
 	}
 
@@ -560,12 +811,12 @@ namespace gctl
 		/**
 		 * @brief 填充二维坐标列
 		 * 
-		 * @param xid x坐标列索引
-		 * @param yid y坐标列索引
+		 * @param xid x坐标列索引 从1开始
+		 * @param yid y坐标列索引 从1开始
 		 * @param data 返回的二维坐标数据 
 		 * @param p 填入的浮点数据有效位数（精度）
 		 */
-		void fill_column_point2dc(int xid, int yid, const array<point2dc> &data, int p = 6);
+		void fill_column_point2dc(const array<point2dc> &data, int xid, int yid, int p = 6);
 
 		/**
 		 * @brief 填充二维坐标列
@@ -575,18 +826,18 @@ namespace gctl
 		 * @param data 返回的二维坐标数据 
 		 * @param p 填入的浮点数据有效位数（精度）
 		 */
-		void fill_column_point2dc(std::string xname, std::string yname, const array<point2dc> &data, int p = 6);
+		void fill_column_point2dc(const array<point2dc> &data, std::string xname, std::string yname, int p = 6);
 
 		/**
 		 * @brief 填充三维坐标列
 		 * 
-		 * @param xid x坐标列索引
-		 * @param yid y坐标列索引
-		 * @param zid z坐标列索引
+		 * @param xid x坐标列索引 从1开始
+		 * @param yid y坐标列索引 从1开始
+		 * @param zid z坐标列索引 从1开始
 		 * @param data 返回的三维坐标数据 
 		 * @param p 填入的浮点数据有效位数（精度）
 		 */
-		void fill_column_point3dc(int xid, int yid, int zid, const array<point3dc> &data, int p = 6);
+		void fill_column_point3dc(const array<point3dc> &data, int xid, int yid, int zid, int p = 6);
 
 		/**
 		 * @brief 填充三维坐标列
@@ -597,16 +848,38 @@ namespace gctl
 		 * @param data 返回的三维坐标数据 
 		 * @param p 填入的浮点数据有效位数（精度）
 		 */
-		void fill_column_point3dc(std::string xname, std::string yname, std::string zname, const array<point3dc> &data, int p = 6);
+		void fill_column_point3dc(const array<point3dc> &data, std::string xname, std::string yname, std::string zname, int p = 6);
+
+		/**
+		 * @brief 填充三维坐标列
+		 * 
+		 * @param rid rad坐标列索引 从1开始
+		 * @param pid phi坐标（经度）列索引 从1开始
+		 * @param tid theta坐标（纬度）列索引 从1开始
+		 * @param data 返回的三维坐标数据 
+		 * @param p 填入的浮点数据有效位数（精度）
+		 */
+		void fill_column_point3ds(const array<point3ds> &data, int rid, int pid, int tid, int p = 6);
+
+		/**
+		 * @brief 填充三维坐标列
+		 * 
+		 * @param rname rad坐标列名称 从1开始
+		 * @param pname phi坐标（经度）列名称 从1开始
+		 * @param tname theta坐标（纬度）列名称 从1开始
+		 * @param data 返回的三维坐标数据 
+		 * @param p 填入的浮点数据有效位数（精度）
+		 */
+		void fill_column_point3ds(const array<point3ds> &data, std::string rname, std::string pname, std::string tname, int p = 6);
 
 		/**
 		 * @brief 读取二维坐标列
 		 * 
-		 * @param xid x坐标列索引
-		 * @param yid y坐标列索引
+		 * @param xid x坐标列索引 从1开始
+		 * @param yid y坐标列索引 从1开始
 		 * @param data 返回的二维坐标数据 
 		 */
-		void get_column_point2dc(int xid, int yid, array<point2dc> &data);
+		void get_column_point2dc(array<point2dc> &data, int xid, int yid);
 
 		/**
 		 * @brief 读取二维坐标列
@@ -615,17 +888,17 @@ namespace gctl
 		 * @param yname y坐标列名称
 		 * @param data 返回的二维坐标数据 
 		 */
-		void get_column_point2dc(std::string xname, std::string yname, array<point2dc> &data);
+		void get_column_point2dc(array<point2dc> &data, std::string xname, std::string yname);
 
 		/**
 		 * @brief 读取三维坐标列
 		 * 
-		 * @param xid x坐标列索引
-		 * @param yid y坐标列索引
-		 * @param zid z坐标列索引
+		 * @param xid x坐标列索引 从1开始
+		 * @param yid y坐标列索引 从1开始
+		 * @param zid z坐标列索引 从1开始
 		 * @param data 返回的三维坐标数据 
 		 */
-		void get_column_point3dc(int xid, int yid, int zid, array<point3dc> &data);
+		void get_column_point3dc(array<point3dc> &data, int xid, int yid, int zid);
 
 		/**
 		 * @brief 读取三维坐标列
@@ -635,7 +908,27 @@ namespace gctl
 		 * @param zname z坐标列名称
 		 * @param data 返回的三维坐标数据 
 		 */
-		void get_column_point3dc(std::string xname, std::string yname, std::string zname, array<point3dc> &data);
+		void get_column_point3dc(array<point3dc> &data, std::string xname, std::string yname, std::string zname);
+
+		/**
+		 * @brief 读取三维坐标列
+		 * 
+		 * @param rid rad坐标列索引 从1开始
+		 * @param pid phi坐标（经度）列索引 从1开始
+		 * @param tid theta坐标（纬度）列索引 从1开始
+		 * @param data 返回的三维坐标数据 
+		 */
+		void get_column_point3ds(array<point3ds> &data, int rid, int pid, int tid);
+
+		/**
+		 * @brief 读取三维坐标列
+		 * 
+		 * @param rname rad坐标列名称 从1开始
+		 * @param pname phi坐标（经度）列名称 从1开始
+		 * @param tname theta坐标（纬度）列名称 从1开始
+		 * @param data 返回的三维坐标数据 
+		 */
+		void get_column_point3ds(array<point3ds> &data, std::string rname, std::string pname, std::string tname);
 	};
 }
 
diff --git a/tool/dsviewer/dsviewer.cpp b/tool/dsviewer/dsviewer.cpp
index f171c27..0157c98 100644
--- a/tool/dsviewer/dsviewer.cpp
+++ b/tool/dsviewer/dsviewer.cpp
@@ -207,11 +207,63 @@ void quit(const std::vector<std::string> &cmd_units)
 
 void info(const std::vector<std::string> &cmd_units)
 {
-    if (cmd_units.size() == 1) // cmd_units[0] == info
+    // info [column|row|both]
+    if (cmd_units.size() > 1)
     {
-        tc.info();
-        return;
+        if (cmd_units[1] == "row") tc.info(RowHead);
+        if (cmd_units[1] == "both") tc.info(BothHead);
     }
+    else tc.info();
+    return;
+}
+
+void set_enable(const std::vector<std::string> &cmd_units)
+{
+    // enable column|row <column> <column>...
+    if (cmd_units.size() < 3) throw std::runtime_error("enable: insufficient parameters.");
+
+    if (cmd_units[1] == "column")
+    {
+        for (size_t i = 2; i < cmd_units.size(); i++)
+        {
+            if (tc.name_index(cmd_units[i]) < 0) tc.column_output(atoi(cmd_units[i].c_str()), Enable);
+            else tc.column_output(cmd_units[i], Enable);
+        }
+    }
+    else if (cmd_units[1] == "row")
+    {
+        for (size_t i = 2; i < cmd_units.size(); i++)
+        {
+            if (tc.name_index(cmd_units[i], true) < 0) tc.row_output(atoi(cmd_units[i].c_str()), Enable);
+            else tc.row_output(cmd_units[i], Enable);
+        }
+    }
+    else throw std::runtime_error("enable: invalid parameters.");
+    return;
+}
+
+void set_disable(const std::vector<std::string> &cmd_units)
+{
+    // disable column|row <column> <column>...
+    if (cmd_units.size() < 3) throw std::runtime_error("disable: insufficient parameters.");
+
+    if (cmd_units[1] == "column")
+    {
+        for (size_t i = 2; i < cmd_units.size(); i++)
+        {
+            if (tc.name_index(cmd_units[i]) < 0) tc.column_output(atoi(cmd_units[i].c_str()), Disable);
+            else tc.column_output(cmd_units[i], Enable);
+        }
+    }
+    else if (cmd_units[1] == "row")
+    {
+        for (size_t i = 2; i < cmd_units.size(); i++)
+        {
+            if (tc.name_index(cmd_units[i], true) < 0) tc.row_output(atoi(cmd_units[i].c_str()), Disable);
+            else tc.row_output(cmd_units[i], Enable);
+        }
+    }
+    else throw std::runtime_error("disable: invalid parameters.");
     return;
 }
 
@@ -279,7 +331,7 @@ void statistic(const std::vector<std::string> &cmd_units)
     _1d_array data;
     for (size_t i = 1; i < cmd_units.size(); i++)
     {
-        tc.get_column(cmd_units[i], data);
+        tc.get_column(data, cmd_units[i]);
         std::clog << "column: " << cmd_units[i] 
             << " | " << data.min() << "/" << data.mean() << "/" << data.max() 
             << " | STD: " << data.std() << "\n"; 
diff --git a/tool/dsviewer/dsviewer.h b/tool/dsviewer/dsviewer.h
index 495e933..751ed58 100644
--- a/tool/dsviewer/dsviewer.h
+++ b/tool/dsviewer/dsviewer.h
@@ -48,14 +48,18 @@ void info(const std::vector<std::string> &cmd_units);
 void load_file(const std::vector<std::string> &cmd_units);
 void save_file(const std::vector<std::string> &cmd_units);
 void statistic(const std::vector<std::string> &cmd_units);
+void set_enable(const std::vector<std::string> &cmd_units);
+void set_disable(const std::vector<std::string> &cmd_units);
 
-#define CMD_NUM 6
+#define CMD_NUM 8
 const cmd_pair commands[CMD_NUM] = {
     {"quit", quit, "Quit the program."},
     {"info", info, "Show the table information."},
     {"open", load_file, "Open a dsv/csv file."},
     {"save", save_file, "Save the table to a file."},
     {"stats", statistic, "Calculate statistics of the selected columns."},
+    {"enable", set_enable, "Enable column/row outputs by name or index."},
+    {"disable", set_disable, "Disable column/row outputs by name or index."},
     {"null", nullptr, "null"}
 };