tmp

src/core/dsv_io_ex.cpp

@@ -31,7 +31,7 @@ using namespace gctl;
 
 int main(int argc, char const *argv[]) try
 {
-
+    /*
     dsv_io tc;
     tc.delimeter('|');
     tc.head_number(1);
@@ -48,23 +48,24 @@ int main(int argc, char const *argv[]) try
     //tc2.head_records(tc.head_records());
     tc2.delimeter('|');
     tc2.save_text("out");
+    */
 
-/*
+    /*
     geodsv_io tc;
-    tc.load_text("tmp/topo", ".txt", ColumnHead);
+    tc.load_text("tmp/topo", ".txt", ColHead);
-    tc.set_column_names({"x (m)", "y (m)", "elev (m)"});
+    tc.column_names({"x (m)", "y (m)", "elev (m)"});
-    tc.set_column_type(Float, "x (m)");
+    tc.column_type(Float, "x (m)");
-    tc.set_column_type(Float, "y (m)");
+    tc.column_type(Float, "y (m)");
-    tc.set_column_type(Float, "elev (m)");
+    tc.column_type(Float, "elev (m)");
 
     array<point3dc> 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";
-    display_vector(tc.get_tags(), std::clog, '\n');
+    display_vector(tc.tags(), std::clog, '\n');
-    display_vector(tc.get_annotoations(), std::clog, '\n');
+    display_vector(tc.annotations(), std::clog, '\n');
-    display_vector(tc.get_head_records(), std::clog, '\n');
+    display_vector(tc.head_records(), std::clog, '\n');
 
     //tc.column_output("C3", Disable);
     
@@ -72,30 +73,34 @@ int main(int argc, char const *argv[]) try
     tc.get_column(elev, "elev (m)");
     elev.for_each([](double &d, size_t i){d += 100.0;});
 
-    tc.add_column(2, "elev_plus");
+    tc.add_column("elev_plus", 2);
     tc.fill_column(elev, "elev_plus");
 
-    tc.add_column(-1, "dist");
+    tc.add_column("dist", -1);
     tc.cal_column("dist := sqrt(C1*C1 + C3*C3)", {"dist", "C1", "C3"});
 
-    tc.add_row(3);
+    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.cal_column("dist > 1000", {"x (m)", "y (m)", "elev (m)"});
-    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();
+    _1s_vector s = tc.tags();
     s.push_back("Elev = 1000");
-    tc.set_tags(s);
+    tc.tags(s);
     tc.save_csv("out");
 
     double c = 4.25242153654;
     tc.cell(c, 2, 1, 12);
     std::clog << std::setprecision(12) << tc.cell<double>(2, 1) << "\n";
 
-    tc.info();
+    tc.info(ColHead);
-*/
+    */
+
+    dsv_io tio;
+    _1d_array wgt;
+    tio.load_text("data/table_sample", ".txt");
+    tio.get_column(wgt, 4);
+    wgt.show();
     return 0;
 }
 catch(std::exception &e)

src/core/fft2d_ex.cpp

@@ -64,9 +64,9 @@ void average_radian_spec(const array<double> &in_freq, const array<double> &in_p
 
         if (!bin.empty())
         {
-            bin_arr.import_vector(bin);
+            vector2array(bin, bin_arr);
-            out_power[i] = bin_arr.mean();
+            out_power[i] = mean(bin_arr);
-            out_std[i] = bin_arr.std();
+            out_std[i] = gctl::std(bin_arr);
         }
     }
     return;
@@ -83,10 +83,10 @@ int main(int argc, char const *argv[]) try
     _2d_matrix sig(M, N);
     _1d_array X(N), Y(M);
     _1d_array U(N), V(M);
-    X.sequence(-1.0, dT);
+    sequence(X, -1.0, dT);
-    Y.sequence(-1.0, dT);
+    sequence(Y, -1.0, dT);
-    U.sequence(-1.0*freq, 2.0*freq/(N - 1));
+    sequence(U, -1.0*freq, 2.0*freq/(N - 1));
-    V.sequence(-1.0*freq, 2.0*freq/(M - 1));
+    sequence(V, -1.0*freq, 2.0*freq/(M - 1));
 
     double t;
     double f1 = 40.0;
@@ -129,7 +129,7 @@ int main(int argc, char const *argv[]) try
 
     _1d_array out_freq, out_power, out_std;
     out_freq.resize(150);
-    out_freq.sequence(1.0, 1.0);
+    sequence(out_freq, 1.0, 1.0);
     average_radian_spec(pro_freq, pro_spec, out_freq, out_power, out_std);
 
     std::ofstream ofile;

src/core/fft_filter_ex.cpp

@@ -51,7 +51,7 @@ int main(int argc, char const *argv[]) try
     // Create input signal
     int snum = int(10.13*fs);
     gctl::array<double> t(snum), signal(snum);
-    t.sequence(0.0, 10.13/(snum - 1));
+    sequence(t, 0.0, 10.13/(snum - 1));
 
     for (size_t i = 0; i < t.size(); i++)
     {

src/core/fir_filter_ex.cpp

@@ -58,7 +58,7 @@ int main(int argc, char const *argv[]) try
     // Create input signal
     int snum = int(10.13*fs);
     gctl::array<double> t(snum), signal(snum);
-    t.sequence(0.0, 10.13/(snum - 1));
+    sequence(t, 0.0, 10.13/(snum - 1));
 
     for (size_t i = 0; i < t.size(); i++)
     {

src/optimization/ex10.cpp

@@ -48,7 +48,7 @@ int main(int argc, char const *argv[])
 	A[3][1] = 1;
 
     gctl::array<double> x(3), y(3), m(3);
-    x.random_float(-1.0, 1.0, gctl::RdUniform, 452);
+	random_float(x, -1.0, 1.0, gctl::RdUniform, 452);
     gctl::matvec(y, A, x);
 
 	cout<<"A(" << A.row_size() << ", " << A.col_size() << ") = " <<endl;

src/optimization/ex7.cpp

@@ -62,7 +62,7 @@ private:
 ex7::ex7()
 {
     gctl::array<double> tmp(round(0.5*(N+1)*N));
-    tmp.random_float(1.0, 2.0, gctl::RdUniform);
+    random_float(tmp, 1.0, 2.0, gctl::RdUniform);
 
     size_t c = 0;
     kernel.resize(N, N);
@@ -95,7 +95,7 @@ int main(int argc, char const *argv[])
 {
 	// 生成一组正演解
     gctl::array<double> tmp(2*N);
-    tmp.random_float(1.0, 2.0, gctl::RdUniform);
+    random_float(tmp, 1.0, 2.0, gctl::RdUniform);
 
     cd_array fm(N);
     for (size_t i = 0; i < N; i++)

src/optimization/ex8.cpp

@@ -133,25 +133,25 @@ double ex8::LBFGS_Evaluate(const gctl::_1d_array &x, gctl::_1d_array &g)
     tmp -= obs1;
 
     gctl::matvec(grad, k1, tmp, gctl::Trans);
-    grad.scale(2.0/M);
+    grad *= 2.0/M;
 
-    AddSingleLoss(gctl::power2(tmp.module(gctl::L2))/M, grad);
+    AddSingleLoss(gctl::power2(module(tmp, gctl::L2))/M, grad);
 
     gctl::matvec(tmp, k2, x);
     tmp -= obs2;
 
     gctl::matvec(grad, k2, tmp, gctl::Trans);
-    grad.scale(2.0/M);
+    grad *= 2.0/M;
 
-   	AddSingleLoss(gctl::power2(tmp.module(gctl::L2))/M, grad);
+   	AddSingleLoss(gctl::power2(module(tmp, gctl::L2))/M, grad);
 
     gctl::matvec(tmp, k3, x);
     tmp -= obs3;
 
     gctl::matvec(grad, k3, tmp, gctl::Trans);
-    grad.scale(2.0/M);
+    grad *= 2.0/M;
 
-    AddSingleLoss(gctl::power2(tmp.module(gctl::L2))/M, grad);
+    AddSingleLoss(gctl::power2(module(tmp, gctl::L2))/M, grad);
 
     return GradNormLoss(g);
 }
@@ -194,7 +194,7 @@ int main(int argc, char const *argv[])
 {
 	// 生成一组正演解
     gctl::_1d_array fm(N);
-    fm.random_float(1.0, 2.0, gctl::RdUniform);
+    random_float(fm, 1.0, 2.0, gctl::RdUniform);
 
     ex8 test;
 

src/optimization/ex9.cpp

@@ -52,8 +52,8 @@ int main(int argc, char const *argv[])
     array<double> dist;
     e.get_levy_distribution(dist);
 
-    double m = dist.mean();
+    double m = mean(dist);
-    double s = dist.std();
+    double s = gctl::std(dist);
 
     int c = 0;
     for (size_t i = 0; i < dist.size(); i++)
@@ -61,11 +61,11 @@ int main(int argc, char const *argv[])
         if (dist[i] > m + 3*s) c++;
     }
 
-    std::cout << "mean = " << dist.mean() << "\n";
+    std::cout << "mean = " << mean(dist) << "\n";
-    std::cout << "std = " << dist.std() << "\n";
+    std::cout << "std = " << gctl::std(dist) << "\n";
-    std::cout << "rms = " << dist.rms() << "\n";
+    std::cout << "rms = " << rms(dist) << "\n";
-    std::cout << "max = " << dist.max() << "\n";
+    std::cout << "max = " << max(dist) << "\n";
-    std::cout << "min = " << dist.min() << "\n";
+    std::cout << "min = " << min(dist) << "\n";
     std::cout << "ratio = " << 5000.0*c/dist.size() << "\n";
 
     for (size_t i = 0; i < dist.size(); i++)