Thứ Sáu, 28 tháng 12, 2018

2018 Karl Terzaghi Lecture: Geotechnical Stability of Waste Fills

Dr Rudolph Bonaparte delivered the 2018 Karl Terzaghi Lecture at IFCEE 2018 in Orlando, FL,
on March 8, 2018.

vào lúc

Thứ Bảy, 8 tháng 12, 2018

Julia vs. Python: Chọn Julia cho data science?

(Nguồn xem ở đây)

Với nhiều lĩnh vực có thể dùng tới Python, có lẽ phân tích dữ liệu là có ảnh hưởng nhiều nhất. Python có hệ sinh thái vô cùng phong phú với libraries, tools, và applications giúp cho công việc của ngành khoa học máy tính và phân tích dữ liệu trở nên tiện lợi và nhanh hơn rất nhiều.
Nhưng với các developer đằng sau ngôn ngữ lập trình Julia – dành riêng cho “khoa học máy tính, khai thác dữ liệu, đại số tuyến tính quy mô lớn, phân phối và tính toán song song” – Python vẫn chưa nhanh và tiện dụng theo như kì vọng của họ.

Julia là ngôn ngữ lập trình gì?

Được tạo ra vào 2009 bởi nhóm 4 thành viên và ra mắt cộng đồng trong năm 2012, Julia là giải pháp giúp thay Python và các ngôn ngữ khác khi làm về khoa học máy tính và xử lý dữ liệu. “Chúng tôi rất tham lam” – nhóm phát triển viết. Họ luôn đòi hỏi nhiều hơn nữa:
Chúng tôi muốn một ngôn ngữ open source, với giấy phép tự do. Chúng tôi muốn tốc độ của C và sức mạnh của Ruby. Một ngôn ngữ đồng tính, với các macros thật sự như Lisp nhưng lại có các ký hiệu toán học như Matlab. Một ngôn ngữ dễ dùng cho nhiều mục đích khác nhau như Python, thật dễ khi nói về số liệu như R và tự nhiên khi liên quan tới quá trình string của Perl. Chúng tôi muốn nó phải thật dễ học nhưng lại vẫn thỏa mãn ngay cả kẻ khó tính nhất. Nó cũng phải vừa interactive và compiled.
Sau đây là cách thức để Julia có thể đạt được những điều trên:
Compiled, không interpreted, cho tốc độ. Julia là just-in-time (JIT) compiled sử dụng LLVM compiler framework. Cho phép nó có khả năng đạt được tốc độ tương tự như C.
Cú pháp ngắn gọn như hữu dụng. Các cú pháp của Julia khá tương đồng với Python, nhưng đồng thời lại vô cùng mạnh mẽ.
Các lợi ích từ dynamic typing với static type. Bạn có thể chỉ định type cho variables. Nhưng bạn cũng có thể tạo ra cấp bậc của types nhằm có thể xử lí các variables của một vài types nhất định.
Có thể sử dụng Python, C, và Fortran libraries. Julia có thể trực tiếp sữ dụng những libraries của C và Fortran. Nó cũng có khả năng dùng code của Python thông qua PyCall library.
Metaprogramming. Julia programs có thể tạo ra những Julia programs khác, thậm chí sửa đổi chính code của chúng, theo cách tương tự như các ngôn ngữ lập trình như Lisp.

Julia vs Python: Thế mạnh của Julia

Julia được thiết kế ngay từ đầu với mục đích dành cho khoa học và tính toán số. Do đó mà không có gì ngạc nhiên khi nó có nhiều thế mạnh nằm trong lĩnh vực này:
Nhanh hơn khi ở default. Julia’s JIT compilation và type declarations giúp cho việc nó có thể chiến thắng phiên bản Python (không được tinh chỉnh). Tuy rằng Python có thể trở nên nhanh hơn nhờ vào libraries, third-party JIT compilers (PyPy), và tool nhưng nếu so ở mức default thì Julia lại chính là người chiến thắng.
Thuật toán thân thiện với toán học. Nhóm người dùng chính mà Julia nhắm tới là các developer sử dụng các ngôn ngữ tính toán khoa học như Matlab, R, Mathematica, và Octave. Các thuật toán của Julia sẽ nhìn trông giống các công thức toán học, nhờ đó mà người mới học sẽ tiếp thu nhanh hơn.
Quản lý bộ nhớ tự động. Như Python, Julia không đè nặng user với việc allocating và giải phóng bộ nhớ. Ý tưởng ở đây chính là việc dù bạn có nhảy qua Julia, thì những tính năng tiện dụng của Python vẫn có mặt trên ngôn ngữ lập trình này.
Parallelism – tính song song. Toán học và tính toán khoa học sẽ phát triển khi bạn có thể sử dụng mọi nguồn tồn tại trên máy, đặc biệt là với nhiều core. Cả Python và Julia đều có thể điều hành hoạt động song song. Nhưng thuật toán của Julia sẽ nặng phần top hơn so với Python.

Python vs Julia: Thế mạnh của Python

Python là một ngôn ngữ đa dụng, vừa dễ học cũng như được đánh giá là một trong những lựa chọn tốt nhất cho khoa học máy tính. Một số nguyên nhân vì sao Python vẫn là ứng viên sáng giá đối với khoa học dữ liệu.
Julia arrays là 1-indexed. Do điều này khiến cho nó không thật sự tương thích với Python và C vốn bắt đầu từ 0. Do đó mà tuy rằng Julia vô cùng thích hợp trong lĩnh vực toán học và tính toán nâng cao nhưng nó lại không hề mạnh với những lĩnh vực khác như Python.
Julia vẫn còn quá trẻ. Chỉ mới ra đời từ 2009, dù rằng ngôn ngữ đã có phát triển vượt bậc nhưng hiện tại nó vẫn chưa tới được phiên bản 1.0 chính thức của mình.
Python có nhiều packages hỗ trợ hơn. Trong khi đó, Julia với tuổi đời trẻ tất nhiên sẽ cần tới việc đa dạng hóa các package dành cho nó nhằm có thể thật sự phát triển vượt bậc.
Python có cộng đồng vô cùng đông đảo. Dù rằng các thành viên của Julia đều là những developer đầy nhiệt huyết nhưng khi so với Python thì nó vẫn vô cùng nhỏ bé.
vào lúc

Thứ Hai, 3 tháng 12, 2018

International Society for Soil Mechanics and Geotechnical Engineering Lectures

CHALLENGES IN SHORING DEEP EXCAVATIONS IN URBAN AREAS
Presenter: Dr. Marc Ballouz
Title: Challenges in Shoring Deep Excavations in Urban Areas
Launching Date & Time: 13th of December 2016 12:00pm GMT

mballouz-webinar
COMBINED LOADING OF OFFSHORE FOUNDATIONS
Presenter: Prof. Mark Cassidy
Title: Combined Loading of Offshore Foundations
Launching Date & Time: 24th of August 2016 12:00pm GMT


vào lúc

Thứ Năm, 29 tháng 11, 2018

Simplified Critical-State Soil Mechanics 2014

vào lúc

Thứ Hai, 26 tháng 11, 2018

3D Envelopes

3D ENVELOPE

Authors
Dan Halperin, Michal Meyerovitch, Ron Wein, and Baruch Zukerman

1 Introduction

A continuous surface S in R3 is called xy-monotone, if every line parallel to the z-axis intersects it at a single point at most. For example, the sphere x2+y2+z2=1 is not xy-monotone as the z-axis intersects it at (0,0,−1) and at (0,0,1); however, if we use the xy-plane to split it to an upper hemisphere and a lower hemisphere, these two hemispheres are xy-monotone.
An xy-monotone surface can therefore be represented as a bivariate function z=S(x,y), defined over some continuous range RS⊆R2. Given a set S={S1,S2,…,Sn} of xy-monotone surfaces, their lower envelope is defined as the point-wise minimum of all surfaces. Namely, the lower envelope of the set S can be defined as the following function:
LS(x,y)=min1≤k≤nS¯¯¯k(x,y) ,
where we define S¯¯¯k(x,y)=Sk(x,y) for (x,y)∈RSk, and S¯¯¯k(x,y)=∞ otherwise.
Similarly, the upper envelope of S is the point-wise maximum of the xy-monotone surfaces in the set:
US(x,y)=max1≤k≤nS––k(x,y) ,
where in this case S––k(x,y)=−∞ for (x,y)∉RSk.
Given a set of xy-monotone surfaces S, the minimization diagram of S is a subdivision of the xy-plane into cells, such that the identity of the surfaces that induce the lower diagram over a specific cell of the subdivision (be it a face, an edge, or a vertex) is the same. In non-degenerate situation, a face is induced by a single surface (or by no surfaces at all, if there are no xy-monotone surfaces defined over it), an edge is induced by a single surface and corresponds to its projected boundary, or by two surfaces and corresponds to their projected intersection curve, and a vertex is induced by a single surface and corresponds to its projected boundary point, or by three surfaces and corresponds to their projected intersection point. The maximization diagram is symmetrically defined for upper envelopes. In the rest of this chapter, we refer to both these diagrams as envelope diagrams.
It is easy to see that an envelope diagram is no more than a planar arrangement (see Chapter 2D Arrangements), represented using an extended Dcel structure, such that every Dcel record (namely each face, halfedge and vertex) stores an additional container of it originators: the xy-monotone surfaces that induce this feature.
Lower and upper envelopes can be efficiently computed using a divide-and-conquer approach. First note that the envelope diagram for a single xy-monotone curve Sk is trivial to compute: we project the boundary of its range of definition RSk onto the xy-plane, and label the faces it induces accordingly. Given a set D of (non necessarily xy-monotone) surfaces in R3, we subdivide each surface into a finite number of weakly xy-monotone surfaces, [1] and obtain the set S. Then, we split the set into two disjoint subsets S1 and S2, and we compute their envelope diagrams recursively. Finally, we merge the diagrams, and we do this by overlaying them and then applying some post-processing on the resulting diagram. The post-processing stage is non-trivial and involves the projection of intersection curves onto the xy-plane - see [1] for more details.

2 The Envelope-Traits Concept

The implementation of the envelope-computation algorithm is generic and can handle arbitrary surfaces. It is parameterized with a traits class, which defines the geometry of surfaces it handles, and supports all the necessary functionality on these surfaces, and on their projections onto the xy-plane. The traits class must model the EnvelopeTraits_3 concept, the details of which are given below.
As the representation of envelope diagrams is based on 2D arrangements, and the envelop-computation algorithm employs overlay of planar arrangements, the EnvelopeTraits_3 refines the ArrangementXMonotoneTraits_2 concept. Namely, a model of this concept must define the planar types Point_2 and X_monotone_curve_2 and support basic operations on them, as listed in Section Traits Classes. Moreover, it must define the spacial types Surface_3 and Xy_monotone_surface_3 (in practice, these two types may be the same). Any model of the envelope-traits concept must also support the following operations on these spacial types:
compare_over_point.png
compare_over_curve.png
(a)(b)
Figure 38.1 (a) The spheres S1 and S2 have only one two-dimensional point p in their common xy-definition range. They do not necessarily intersect over this point, and the envelope-construction algorithm needs to determine their relative z-order over p. (b) The z-order of the surfaces S1 and S2 should be determined over the x-monotone curve c. The comparison is performed over the interior of c, excluding its endpoints.

  • Subdivide a given surface into continuous xy-monotone surfaces. It is possible to disregard xy-monotone surfaces that do not contribute to the surface envelope at this stage (for example, if we are given a sphere, it is possible to return just its lower hemisphere if we are interested in the lower envelope; the upper hemisphere is obviously redundant).
  • Given an xy-monotone surface S, construct all planar curves that form the boundary of the vertical projection S's boundary onto the xy-plane.
    This operation is used at the bottom of the recursion to build the minimization diagram of a single xy-monotone surface.
  • Construct all geometric entities that comprise the projection (onto the xy-plane) of the intersection between two xy-monotone surfaces S1 and S2. These entities may be:
    • A planar curve, which is the projection of an 3D intersection curve of S1 and S2 (for example, the intersection curve between two spheres is a 3D circle, which becomes an ellipse when projected onto the xy-plane). In many cases it is also possible to indicate the multiplicity of the intersection: if it is odd, the two surfaces intersect transversely and change their relative z-positions on either side of the intersection curve; if it the multiplicity is even, they maintain their relative z-position. Providing the multiplicity information is optional. When provided, it is used by the algorithm to determine the relative order of S1 and S2 on one side of their intersection curve when their order on the other side of that curve is known, thus improving the performance of the algorithm.
    • A point, induces by the projection of a tangency point of S1 and S2, or by the projection of a vertical intersection curve onto the xy-plane.
    Needless to say, the set of intersection entities may be empty in case S1 and S2 do not intersect.
  • Given two xy-monotone surfaces S1 and S2, and a planar point p=(x0,y0) that lies in their common xy-definition range, determine the z-order of S1 and S2 over p, namely compare S1(x0,y0) and S2(x0,y0). This operation is used only in degenerate situations, in order to determine the surface inducing the envelope over a vertex (see Figure 38.1 (a) for an illustration of a situation when this operation is used).
  • Given two xy-monotone surfaces S1 and S2, and a planar x-monotone curve c, which is a part of their projected intersection, determine the z-order of S1 and S2immediately above (or, similarly, immediately below) the curve c. Note that c is a planar x-monotone curve, and we refer to the region above (or below) it in the plane. If c is a vertical curve, we regard the region to its left as lying above it, and the region to its right as lying below it.
    This operation is used by the algorithm to determine the surface that induce the envelope over a face incident to c.
  • Given two xy-monotone surfaces S1 and S2, and a planar x-monotone curve c, which fully lies in their common xy-definition range, and such that S1 and S2 do not intersect over the interior of c, determine the relative z-order of s1 and s2 over the interior of c. Namely, we compare S1(x0,y0) and S2(x0,y0) for some point (x0,y0) on c.
    This operation is used by the algorithm to determine which surface induce the envelope over an edge associated with the x-monotone curve c, or of a face incident to c, in situations where the previous predicate cannot be used, as c is not an intersection curve of S1 and S2 (see Figure 38.1 (b) for an illustration of a situation where this operation is used).
The package currently contains a traits class for named Env_triangle_traits_3<Kernel> handling 3D triangles, and another named Env_sphere_traits_3<ConicTraits> for 3D spheres, based on geometric operations on conic curves (ellipses). In addition, the package includes a traits-class decorator that enables users to attach external (non-geometric) data to surfaces. The usage of the various traits classes is demonstrated in the next section.

3 Examples

3.1 Example for Envelope of Triangles

ex_triangles.png
ex_tri_le.png
ex_tri_ue.png
(a)(b)(c)
Figure 38.2 (a) Two triangles in R3, as given in envelope_triangles.cpp. (b) Their lower envelope. (c) Their upper envelope.

The following example shows how to use the envelope-traits class for 3D triangles and how to traverse the envelope diagram. It constructs the lower and upper envelopes of the two triangles, as depicted in Figure 38.2 (a) and prints the triangles that induce each face and each edge in the output diagrams. For convenience, we use the traits-class decorator Env_surface_data_traits_3 to label the triangles. When printing the diagrams, we just output the labels of the triangles:
// Constructing the lower and the upper envelope of a set of triangles.
#include <CGAL/Exact_rational.h>
#include <CGAL/Cartesian.h>
#include <CGAL/Env_triangle_traits_3.h>
#include <CGAL/Env_surface_data_traits_3.h>
#include <CGAL/envelope_3.h>
#include <iostream>
#include <list>
typedef CGAL::Exact_rational Number_type;
typedef CGAL::Cartesian<Number_type> Kernel;
typedef CGAL::Env_triangle_traits_3<Kernel> Traits_3;
typedef Kernel::Point_3 Point_3;
typedef Traits_3::Surface_3 Triangle_3;
typedef CGAL::Env_surface_data_traits_3<Traits_3, char> Data_traits_3;
typedef Data_traits_3::Surface_3 Data_triangle_3;
typedef CGAL::Envelope_diagram_2<Data_traits_3> Envelope_diagram_2;
/* Auxiliary function - print the features of the given envelope diagram. */
void print_diagram (const Envelope_diagram_2& diag)
{
// Go over all arrangement faces.
Envelope_diagram_2::Face_const_iterator fit;
Envelope_diagram_2::Ccb_halfedge_const_circulator ccb;
Envelope_diagram_2::Surface_const_iterator sit;
for (fit = diag.faces_begin(); fit != diag.faces_end(); ++fit)
{
// Print the face boundary.
if (fit->is_unbounded())
{
std::cout << "[Unbounded face]";
}
else
{
// Print the vertices along the outer boundary of the face.
ccb = fit->outer_ccb();
std::cout << "[Face] ";
do
{
std::cout << '(' << ccb->target()->point() << ") ";
++ccb;
} while (ccb != fit->outer_ccb());
}
// Print the labels of the triangles that induce the envelope on this face.
std::cout << "--> " << fit->number_of_surfaces()
<< " triangles:";
for (sit = fit->surfaces_begin(); sit != fit->surfaces_end(); ++sit)
std::cout << ' ' << sit->data();
std::cout << std::endl;
}
// Go over all arrangement edges.
Envelope_diagram_2::Edge_const_iterator eit;
for (eit = diag.edges_begin(); eit != diag.edges_end(); ++eit)
{
// Print the labels of the triangles that induce the envelope on this edge.
std::cout << "[Edge] (" << eit->source()->point()
<< ") (" << eit->target()->point()
<< ") --> " << eit->number_of_surfaces()
<< " triangles:";
for (sit = eit->surfaces_begin(); sit != eit->surfaces_end(); ++sit)
std::cout << ' ' << sit->data();
std::cout << std::endl;
}
return;
}
/* The main program: */
int main ()
{
// Construct the input triangles, makred A and B.
std::list<Data_triangle_3> triangles;
triangles.push_back (Data_triangle_3 (Triangle_3 (Point_3 (0, 0, 0),
Point_3 (0, 6, 0),
Point_3 (5, 3, 4)),
'A'));
triangles.push_back (Data_triangle_3 (Triangle_3 (Point_3 (6, 0, 0),
Point_3 (6, 6, 0),
Point_3 (1, 3, 4)),
'B'));
// Compute and print the minimization diagram.
Envelope_diagram_2 min_diag;
CGAL::lower_envelope_3 (triangles.begin(), triangles.end(),
min_diag);
std::cout << std::endl << "The minimization diagram:" << std::endl;
print_diagram (min_diag);
// Compute and print the maximization diagram.
Envelope_diagram_2 max_diag;
CGAL::upper_envelope_3 (triangles.begin(), triangles.end(),
max_diag);
std::cout << std::endl << "The maximization diagram:" << std::endl;
print_diagram (max_diag);
return (0);
}

3.2 Example for Envelope of Spheres

The next example demonstrates how to instantiate and use the envelope-traits class for spheres, based on the Arr_conic_traits_2 class that handles the projected intersecion curves. The program reads a set of spheres from an input file and constructs their lower envelope:
// Constructing the lower envelope of a set of spheres read from a file.
#include <CGAL/basic.h>
#ifndef CGAL_USE_CORE
#include <iostream>
int main()
{
std::cout << "Sorry, this example needs CORE ..." << std::endl;
return 0;
}
#else
#include <CGAL/Cartesian.h>
#include <CGAL/CORE_algebraic_number_traits.h>
#include <CGAL/Arr_conic_traits_2.h>
#include <CGAL/Env_sphere_traits_3.h>
#include <CGAL/envelope_3.h>
#include <CGAL/Timer.h>
#include <iostream>
#include <list>
typedef CGAL::CORE_algebraic_number_traits Nt_traits;
typedef Nt_traits::Rational Rational;
typedef Nt_traits::Algebraic Algebraic;
typedef CGAL::Cartesian<Rational> Rat_kernel;
typedef Rat_kernel::Point_3 Rat_point_3;
typedef CGAL::Cartesian<Algebraic> Alg_kernel;
typedef CGAL::Arr_conic_traits_2<Rat_kernel, Alg_kernel, Nt_traits>
Conic_traits_2;
typedef CGAL::Env_sphere_traits_3<Conic_traits_2> Traits_3;
typedef Traits_3::Surface_3 Sphere_3;
typedef CGAL::Envelope_diagram_2<Traits_3> Envelope_diagram_2;
int main(int argc, char **argv)
{
// Get the name of the input file from the command line, or use the default
// fan_grids.dat file if no command-line parameters are given.
const char * filename = (argc > 1) ? argv[1] : "spheres.dat";
// Open the input file.
std::ifstream in_file(filename);
if (! in_file.is_open())
{
std::cerr << "Failed to open " << filename << " ..." << std::endl;
return 1;
}
// Read the spheres from the file.
// The input file format should be (all coordinate values are integers):
// <n> // number of spheres.
// <x_1> <y_1> <x_1> <R_1> // center and squared radious of sphere #1.
// <x_2> <y_2> <x_2> <R_2> // center and squared radious of sphere #2.
// : : : :
// <x_n> <y_n> <x_n> <R_n> // center and squared radious of sphere #n.
int n = 0;
std::list<Sphere_3> spheres;
int x = 0, y = 0, z = 0, sqr_r = 0;
int i;
in_file >> n;
for (i = 0; i < n; ++i)
{
in_file >> x >> y >> z >> sqr_r;
spheres.push_back(Sphere_3(Rat_point_3(x, y, z), Rational(sqr_r)));
}
in_file.close();
// Compute the lower envelope.
Envelope_diagram_2 min_diag;
CGAL::Timer timer;
std::cout << "Constructing the lower envelope of "
<< n << " spheres." << std::endl;
timer.start();
CGAL::lower_envelope_3(spheres.begin(), spheres.end(), min_diag);
timer.stop();
// Print the dimensions of the minimization diagram.
std::cout << "V = " << min_diag.number_of_vertices()
<< ", E = " << min_diag.number_of_edges()
<< ", F = " << min_diag.number_of_faces() << std::endl;
std::cout << "Construction took " << timer.time()
<< " seconds." << std::endl;
return 0;
}
#endif

3.3 Example for Envelope of Planes

The next example demonstrates how to instantiate and use the envelope-traits class for planes, based on the Arr_linear_traits_2 class that handles infinite linear objects such as lines and rays.
// Constructing the lower and the upper envelope of a set of planes.
#include <CGAL/Exact_rational.h>
#include <CGAL/Cartesian.h>
#include <CGAL/Env_plane_traits_3.h>
#include <CGAL/envelope_3.h>
#include <iostream>
#include <list>
typedef CGAL::Exact_rational Number_type;
typedef CGAL::Cartesian<Number_type> Kernel;
typedef Kernel::Plane_3 Plane_3;
typedef CGAL::Env_plane_traits_3<Kernel> Traits_3;
typedef Traits_3::Surface_3 Surface_3;
typedef CGAL::Envelope_diagram_2<Traits_3> Envelope_diagram_2;
/* Auxiliary function - print the features of the given envelope diagram. */
void print_diagram (const Envelope_diagram_2& diag)
{
// Go over all arrangement faces.
Envelope_diagram_2::Face_const_iterator fit;
Envelope_diagram_2::Ccb_halfedge_const_circulator ccb;
Envelope_diagram_2::Surface_const_iterator sit;
for (fit = diag.faces_begin(); fit != diag.faces_end(); ++fit)
{
// Print the face boundary.
// Print the vertices along the outer boundary of the face.
ccb = fit->outer_ccb();
std::cout << "[Face] ";
do
{
if(!ccb->is_fictitious())
std::cout << '(' << ccb->curve() << ") ";
++ccb;
} while (ccb != fit->outer_ccb());
// Print the planes that induce the envelope on this face.
std::cout << "--> " << fit->number_of_surfaces()
<< " planes:";
for (sit = fit->surfaces_begin(); sit != fit->surfaces_end(); ++sit)
std::cout << ' ' << sit->plane();
std::cout << std::endl;
}
return;
}
/* The main program: */
int main ()
{
// Construct the input planes.
std::list<Surface_3> planes;
planes.push_back (Surface_3(Plane_3(0, -1, 1, 0)));
planes.push_back (Surface_3(Plane_3(-1, 0, 1, 0)));
planes.push_back (Surface_3(Plane_3(0, 1 , 1, 0)));
planes.push_back (Surface_3(Plane_3(1, 0, 1, 0)));
// Compute and print the minimization diagram.
Envelope_diagram_2 min_diag;
CGAL::lower_envelope_3 (planes.begin(), planes.end(), min_diag);
std::cout << std::endl << "The minimization diagram:" << std::endl;
print_diagram (min_diag);
// Compute and print the maximization diagram.
Envelope_diagram_2 max_diag;
CGAL::upper_envelope_3 (planes.begin(), planes.end(), max_diag);
std::cout << std::endl << "The maximization diagram:" << std::endl;
print_diagram (max_diag);
return (0);
}
  1. ^We consider vertical surfaces, namely patches of planes that are perpendicular to the xy-plane, as weakly xy-monotone, to handle degenerate inputs properly.

vào lúc
Đăng ký: Bài đăng (Atom)