This month's theme features three manga series. The one that's not familiar to me is Fairy Tail, though it sounds like a lot of fum from what I've read! It follows the adventures of a wizard who is a member of a guild called Fairy Tail, and as you might expect involves lots of magic and magical creatures.
There's only one figure in this month's box, but it's a nice one: Sword Art Online SEGA Limited Premium Figure ASUNA.
This is a fairly large 8.3″ figure of Asuna in her Aincrad outfit. It also includes the stand, and it's a terrific dynamic pose, especially with the flying hair!
The detailing is very nice, and the single leg stand is impressive.
This is currently retailing on Amazon for a little over £26!
It's a One Piece Wanted Poster Standing Display which is a plastic frame with a cardboard insert with one of nine different wanted posters. This one is of Trafalgar Law.
According to the menu there is supposed to be just one poster included, but my package included two, thought they are both the same character. I'm not sure if this is intentional, as I can't find this particular piece of merch online. I also couldn't figure out quite how to work the stand. The posters themselves are very small, about 3″ x 2″ so they kind of make me think of a doll house accessory! As I can't find them online it's possible these are Asia-exclusive, but they'd be a cute thing for a collector. I don't have a price but at a guess perhaps £6?
Lootaku did an amazing backpack back in 2017, and now here's another one! This one is a Fairy Tail Backpack, and it's really nice.
It's made from black canvas and lined with brown cotton. There's a big Natsu logo on the front, which is a large flap pocket, and a smaller Fairy Tale logo lower down. There are also two bottle pockets on the side, and inside is a laptop pocket, a small zip pocket, and a phone pocket with a passthrough for headphones.
Regardless of whether or not you're familiar with the logos, this looks really good! I managed to find it online for around $31 (£23) not including shipping.
This month's limited edition pin is also a Fairy Tail character, Ezra Scarlet in Heaven's Wheel Armour. As always this is a pretty large pin with excellent detailing. There are two pins on the back because of its size & weight.
I usually value the pins this size at east £6.
Finally, back to One Piece for this month's t-shirt. It shows Trafalgar Law's tattoo on the front, and then the other one on the back of the shirt.
This is a limited edition shirt, and is also 100% cotton, very nice quality. A geek shirt of this quality would be at least £15.
I think this month's combination of items is pretty interesting. While I'm not convinced about the mini Wanted posters, I think the other items are terrific!
As always the figure is excellent, Lootaku always supplies high quality figures.
The t-shirt is very nice, and the design itself is quite subtle.
I think my favourite this month is the backpack! I love it when Lootaku do cool accessories and wearables, and a backpack is incredibly useful. The design looks really striking even if you're not familiar with the subject, and it's got plenty of pockets making this genuinely useful and practical.
There's terrific value this month just for the bag and figure, so even though one of the items is a little strange, overall the value is excellent.
The only slight glitch this month was that shipping happened very late, due to factories shutting down over the Chinese New Year. This box didn't actually arrive until mid-March, but Lootaku are pretty good at keeping people updated on social media so I'm not concerned.
Lootaku figures are always excellent, but I'm also really happy to see practical items too, especially something as cool as this backpack. It's the perfect geek accessory!


text:
require 'pry'
%w(hypervisor).each do |lib|
  begin
    require "vmreverter/#{lib}"
  rescue LoadError
    require File.expand_path(File.join(File.dirname(__FILE__), lib))
  end
end

module Vmreverter

  HYPERVISOR_TYPES = ['vsphere', 'aws']

  #Collection using Proxy Pattern - Proxy normalized access to specific Hypervisors such as VSphere through creation by the Hypervisor Factory
  class VMManager

    attr_accessor :hypervisor_collection

    def self.execute!(config)
      begin
        @vmmanager = Vmreverter::VMManager.new(config)
        @vmmanager.invoke
        @vmmanager.close_connection
      rescue => e
        raise e
      ensure
        FileUtils.rm config.options[:lockfile], :force => true if config.options[:lockfile]
      end
    end #execute!

    def initialize(config)
      @logger = config.logger
      @options = config.options
      @hosts = []
      @config = config
      @hypervisor_collection = {}
      @virtual_machines = {}

      @config['HOSTS'].each_key do |name|
        hypervisor = @config['HOSTS'][name]['hypervisor']
        @logger.debug "Hypervisor for #{name} is #{hypervisor}"
        @virtual_machines[hypervisor] = [] unless @virtual_machines[hypervisor]
        @virtual_machines[hypervisor] << name
      end

      ## Data Model Looks like
      # @virtual_machines.inspect
      # {"vsphere" => ["test_server01","test_server02"], "blimpy" => ["aws_test_server01","aws_test_server01"]}

      @virtual_machines.each do |type, names|
        @hypervisor_collection[type] = Vmreverter::Hypervisor.register(type, names, @config)
      end

      #return instance created
      return self
    end

    def invoke
      @hypervisor_collection.each do |hypervisor_type, hypervisor_instance|
        @logger.notify("Invoking #{hypervisor_type} hosts")
        hypervisor_instance.invoke
      end
    end

    def close_connection
      @hypervisor_collection.each do |hypervisor_type, hypervisor_instance|
        @logger.notify("Disconnecting from #{hypervisor_type}")
        hypervisor_instance.close_connection
      end
    end

  end
end

redpajama_set_name: RedPajamaGithub


External Affairs Minister (EAM) Smt. Sushma Swaraj met Indonesian Foreign Minister Ms. Retno Marsudi in a pull aside meeting on 20 September 2017 on the sidelines of the 72nd session of the UNGA in New York, to discuss Rohingya issue. Ms. Retno Marsudi called for greater coordination between India and Indonesia to help Bangladesh and Myanmar in this crisis saying that continued exodus of Rohingyas from Rakhine due to Myanmar's actions could destabilize the whole region. She appreciated India's humanitarian assistance to Bangladesh through operation Insaniyat. EAM briefed Ms. Retno Marsudi about Prime Minister's meeting with Aung San Suu Kyi on 6 September 2017 and reiterated that India was willing to step up assistance to Myanmar Government for development activities in Rakhine. EAM also referred to Aung San Suu Kyi's address to the nation whereby she expressed willingness to implement the recommendations of the Kofi Annan Commission. Ms. Retno Marsudi briefed EAM about her recent meeting with the Commander-in-Chief of the Myanmar Army.


Pressure Cleaning Mernda is the highest rated, expert pressure cleaning & exterior home washing business in Mernda. We service all residential areas throughout Melbourne and Mornington Peninsula.
Roofings can become really undesirable due to natural growths like moss and lichen. Roofs are likewise often discoloured and stained by a prevalent bacteria called gloecapsa magma. Roofing associations and manufacturers do not suggest high pressure washing to clean roofs. It might get rid of moss from the roof, however the aggressive jets of water might likewise harm tiles, ridge capping and other roofing fittings as well as increase the threat of flooding. There is likewise a good chance that the moss will grow back. Cleaning with the manufacturers preferred detergent is recommended. This is what we do! Softwash roof washing is by far the most efficient method to clear moss or other bacterial growths from the roofing, whenever they are at risk of ending up being a major problem.
We clean up, paint and seal driveways, paths and concrete utilizing our sophisticated cleaning and sealing products. A clean driveway will greatly improve the look, value and street appeal of your home or business. This is accomplished by giving a new look to old and worn out surface areas.
Have you got tired looking timber decks? Our team will make them look brand-new again. We apply a light chemical that will clean up and rejuvenate the wood. This is followed by 2 coats of high quality decking oil or stain. Our process will make your deck look a million dollars and leave you really impressed by the results!
Don't let beginners practice on your biggest investment. Our professional team of service technicians has over 20 years worth of experience, so we know exactly what we are doing. For your assurance we guarantee all our work, and even better, we have very competitive rates. Our service is insured and we're fully accredited to deal with your home or business.
We works with companies throughout Mernda, offering environmentally compliant, high pressure steam cleaning and water blasting services that allow organisations to meet hygiene compliance guidelines and provide staff and visitors with a pleasant environment.
Our certified, licensed and totally guaranteed staff clean both indoor and outdoor areas around your company. Our reliable staff are readily available to work after hours to avoid any disturbances to your business. We are also certified and licensed to work at height as our service often includes tall buildings, which might need abseiling or elevated work platforms.
Our company has a strong reputation among its customers for reliability and workmanship. No two jobs are alike, so call us to discuss your brick cleaning Mernda requirements, whether you require a one-off pressure clean or a regular contracted service.


Product prices and availability are accurate as of 2019-04-24 13:40:51 UTC and are subject to change. Any price and availability information displayed on http://www.amazon.co.uk/ at the time of purchase will apply to the purchase of this product.
Having a tough time moving around freely and safely?
Whether it's for your wheelchair, car, or even your wheelbarrow, moving between different floor levels can be difficult for yourself, your dog or your wheels - limiting your freedom of movement.
What you need is something that will give you easy access to any pavement or floor type and level. Something that is easy to set up and portable. What's better than having a stable wheelchair ramp ready anywhere, anytime?
Cross any level with confidence using the Street Solutions UK Rubber Kerb Threshold Ramps.
Whether it's for your home or office, indoor or outdoor, our rubber kerb ramps are definitely a great addition. Not only are they easy to use but they can also be linked seamlessly to any length thanks to their strong-fit linking system. Make a wider ramp for your pet within seconds!
Difficulty in accessing multiple levels will now be a thing of the past. You can now move wheelchairs, disability scooters, a sack or two of flour, and even bulky equipment effortlessly.
That's not all! They can also handle heavy and large loads (Up to 80 tonnes). Unlike alternative wooden or steel ramps, ours are much lighter, easier to handle, sturdier and environmental-friendly. Whether you're at your place or on the go, you can easily move around with our mobility scooter ramps.
? Use them in construction sites for kerb and landscaping protection.
? Made of 100% recycled PVC that won't rust, rot or cross contaminate different sites.
? Our friendly customer relations staff is always ready to respond to your concerns.
Cross any level like a boss. Add our Rubber Kerb Threshold Ramps to your basket TODAY!


text:
// matrix/kaldi-matrix.h

// Copyright 2009-2011  Ondrej Glembek;  Microsoft Corporation;  Lukas Burget;
//                      Saarland University;  Petr Schwarz;  Yanmin Qian;
//                      Karel Vesely;  Go Vivace Inc.;  Haihua Xu
//           2017       Shiyin Kang
//           2019       Yiwen Shao

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.

#ifndef KALDI_MATRIX_KALDI_MATRIX_H_
#define KALDI_MATRIX_KALDI_MATRIX_H_ 1

#include <algorithm>

#include "matrix/matrix-common.h"

namespace kaldi {

/// @{ \addtogroup matrix_funcs_scalar

/// We need to declare this here as it will be a friend function.
/// tr(A B), or tr(A B^T).
template<typename Real>
Real TraceMatMat(const MatrixBase<Real> &A, const MatrixBase<Real> &B,
                 MatrixTransposeType trans = kNoTrans);
/// @}

/// \addtogroup matrix_group
/// @{

/// Base class which provides matrix operations not involving resizing
/// or allocation.   Classes Matrix and SubMatrix inherit from it and take care
/// of allocation and resizing.
template<typename Real>
class MatrixBase {
 public:
  // so this child can access protected members of other instances.
  friend class Matrix<Real>;
  // friend declarations for CUDA matrices (see ../cudamatrix/)
  friend class CuMatrixBase<Real>;
  friend class CuMatrix<Real>;
  friend class CuSubMatrix<Real>;
  friend class CuPackedMatrix<Real>;
  friend class PackedMatrix<Real>;
  friend class SparseMatrix<Real>;
  friend class SparseMatrix<float>;
  friend class SparseMatrix<double>;

  /// Returns number of rows (or zero for empty matrix).
  inline MatrixIndexT  NumRows() const { return num_rows_; }

  /// Returns number of columns (or zero for empty matrix).
  inline MatrixIndexT NumCols() const { return num_cols_; }

  /// Stride (distance in memory between each row).  Will be >= NumCols.
  inline MatrixIndexT Stride() const {  return stride_; }

  /// Returns size in bytes of the data held by the matrix.
  size_t  SizeInBytes() const {
    return static_cast<size_t>(num_rows_) * static_cast<size_t>(stride_) *
        sizeof(Real);
  }

  /// Gives pointer to raw data (const).
  inline const Real* Data() const {
    return data_;
  }

  /// Gives pointer to raw data (non-const).
  inline Real* Data() { return data_; }

  /// Returns pointer to data for one row (non-const)
  inline  Real* RowData(MatrixIndexT i) {
    KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_));
    return data_ + i * stride_;
  }

  /// Returns pointer to data for one row (const)
  inline const Real* RowData(MatrixIndexT i) const {
    KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_));
    return data_ + i * stride_;
  }

  /// Indexing operator, non-const
  /// (only checks sizes if compiled with -DKALDI_PARANOID)
  inline Real&  operator() (MatrixIndexT r, MatrixIndexT c) {
    KALDI_PARANOID_ASSERT(static_cast<UnsignedMatrixIndexT>(r) <
                          static_cast<UnsignedMatrixIndexT>(num_rows_) &&
                          static_cast<UnsignedMatrixIndexT>(c) <
                          static_cast<UnsignedMatrixIndexT>(num_cols_));
    return *(data_ + r * stride_ + c);
  }
  /// Indexing operator, provided for ease of debugging (gdb doesn't work
  /// with parenthesis operator).
  Real &Index (MatrixIndexT r, MatrixIndexT c) {  return (*this)(r, c); }

  /// Indexing operator, const
  /// (only checks sizes if compiled with -DKALDI_PARANOID)
  inline const Real operator() (MatrixIndexT r, MatrixIndexT c) const {
    KALDI_PARANOID_ASSERT(static_cast<UnsignedMatrixIndexT>(r) <
                          static_cast<UnsignedMatrixIndexT>(num_rows_) &&
                          static_cast<UnsignedMatrixIndexT>(c) <
                          static_cast<UnsignedMatrixIndexT>(num_cols_));
    return *(data_ + r * stride_ + c);
  }

  /*   Basic setting-to-special values functions. */

  /// Sets matrix to zero.
  void SetZero();
  /// Sets all elements to a specific value.
  void Set(Real);
  /// Sets to zero, except ones along diagonal [for non-square matrices too]
  void SetUnit();
  /// Sets to random values of a normal distribution
  void SetRandn();
  /// Sets to numbers uniformly distributed on (0, 1)
  void SetRandUniform();

  /*  Copying functions.  These do not resize the matrix! */

  /// Copy given matrix. (no resize is done).
  template<typename OtherReal>
  void CopyFromMat(const MatrixBase<OtherReal> & M,
                   MatrixTransposeType trans = kNoTrans);

  /// Copy from compressed matrix.
  void CopyFromMat(const CompressedMatrix &M);

  /// Copy given spmatrix. (no resize is done).
  template<typename OtherReal>
  void CopyFromSp(const SpMatrix<OtherReal> &M);

  /// Copy given tpmatrix. (no resize is done).
  template<typename OtherReal>
  void CopyFromTp(const TpMatrix<OtherReal> &M,
                  MatrixTransposeType trans = kNoTrans);

  /// Copy from CUDA matrix.  Implemented in ../cudamatrix/cu-matrix.h
  template<typename OtherReal>
  void CopyFromMat(const CuMatrixBase<OtherReal> &M,
                   MatrixTransposeType trans = kNoTrans);

  /// This function has two modes of operation.  If v.Dim() == NumRows() *
  /// NumCols(), then treats the vector as a row-by-row concatenation of a
  /// matrix and copies to *this.
  /// if v.Dim() == NumCols(), it sets each row of *this to a copy of v.
  void CopyRowsFromVec(const VectorBase<Real> &v);

  /// This version of CopyRowsFromVec is implemented in ../cudamatrix/cu-vector.cc
  void CopyRowsFromVec(const CuVectorBase<Real> &v);

  template<typename OtherReal>
  void CopyRowsFromVec(const VectorBase<OtherReal> &v);

  /// Copies vector into matrix, column-by-column.
  /// Note that rv.Dim() must either equal NumRows()*NumCols() or NumRows();
  /// this has two modes of operation.
  void CopyColsFromVec(const VectorBase<Real> &v);

  /// Copy vector into specific column of matrix.
  void CopyColFromVec(const VectorBase<Real> &v, const MatrixIndexT col);
  /// Copy vector into specific row of matrix.
  void CopyRowFromVec(const VectorBase<Real> &v, const MatrixIndexT row);
  /// Copy vector into diagonal of matrix.
  void CopyDiagFromVec(const VectorBase<Real> &v);

  /* Accessing of sub-parts of the matrix. */

  /// Return specific row of matrix [const].
  inline const SubVector<Real> Row(MatrixIndexT i) const {
    KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_));
    return SubVector<Real>(data_ + (i * stride_), NumCols());
  }

  /// Return specific row of matrix.
  inline SubVector<Real> Row(MatrixIndexT i) {
    KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_));
    return SubVector<Real>(data_ + (i * stride_), NumCols());
  }

  /// Return a sub-part of matrix.
  inline SubMatrix<Real> Range(const MatrixIndexT row_offset,
                               const MatrixIndexT num_rows,
                               const MatrixIndexT col_offset,
                               const MatrixIndexT num_cols) const {
    return SubMatrix<Real>(*this, row_offset, num_rows,
                           col_offset, num_cols);
  }
  inline SubMatrix<Real> RowRange(const MatrixIndexT row_offset,
                                  const MatrixIndexT num_rows) const {
    return SubMatrix<Real>(*this, row_offset, num_rows, 0, num_cols_);
  }
  inline SubMatrix<Real> ColRange(const MatrixIndexT col_offset,
                                  const MatrixIndexT num_cols) const {
    return SubMatrix<Real>(*this, 0, num_rows_, col_offset, num_cols);
  }

  /* Various special functions. */
  /// Returns sum of all elements in matrix.
  Real Sum() const;
  /// Returns trace of matrix.
  Real Trace(bool check_square = true) const;
  // If check_square = true, will crash if matrix is not square.

  /// Returns maximum element of matrix.
  Real Max() const;
  /// Returns minimum element of matrix.
  Real Min() const;

  /// Element by element multiplication with a given matrix.
  void MulElements(const MatrixBase<Real> &A);

  /// Divide each element by the corresponding element of a given matrix.
  void DivElements(const MatrixBase<Real> &A);

  /// Multiply each element with a scalar value.
  void Scale(Real alpha);

  /// Set, element-by-element, *this = max(*this, A)
  void Max(const MatrixBase<Real> &A);
  /// Set, element-by-element, *this = min(*this, A)
  void Min(const MatrixBase<Real> &A);

  /// Equivalent to (*this) = (*this) * diag(scale).  Scaling
  /// each column by a scalar taken from that dimension of the vector.
  void MulColsVec(const VectorBase<Real> &scale);

  /// Equivalent to (*this) = diag(scale) * (*this).  Scaling
  /// each row by a scalar taken from that dimension of the vector.
  void MulRowsVec(const VectorBase<Real> &scale);

  /// Divide each row into src.NumCols() equal groups, and then scale i'th row's
  /// j'th group of elements by src(i, j).  Requires src.NumRows() ==
  /// this->NumRows() and this->NumCols() % src.NumCols() == 0.
  void MulRowsGroupMat(const MatrixBase<Real> &src);

  /// Returns logdet of matrix.
  Real LogDet(Real *det_sign = NULL) const;

  /// matrix inverse.
  /// if inverse_needed = false, will fill matrix with garbage.
  /// (only useful if logdet wanted).
  void Invert(Real *log_det = NULL, Real *det_sign = NULL,
              bool inverse_needed = true);
  /// matrix inverse [double].
  /// if inverse_needed = false, will fill matrix with garbage
  /// (only useful if logdet wanted).
  /// Does inversion in double precision even if matrix was not double.
  void InvertDouble(Real *LogDet = NULL, Real *det_sign = NULL,
                      bool inverse_needed = true);

  /// Inverts all the elements of the matrix
  void InvertElements();

  /// Transpose the matrix.  This one is only
  /// applicable to square matrices (the one in the
  /// Matrix child class works also for non-square.
  void Transpose();

  /// Copies column r from column indices[r] of src.
  /// As a special case, if indexes[i] == -1, sets column i to zero.
  /// all elements of "indices" must be in [-1, src.NumCols()-1],
  /// and src.NumRows() must equal this.NumRows()
  void CopyCols(const MatrixBase<Real> &src,
                const MatrixIndexT *indices);

  /// Copies row r from row indices[r] of src (does nothing
  /// As a special case, if indexes[i] == -1, sets row i to zero.
  /// all elements of "indices" must be in [-1, src.NumRows()-1],
  /// and src.NumCols() must equal this.NumCols()
  void CopyRows(const MatrixBase<Real> &src,
                const MatrixIndexT *indices);

  /// Add column indices[r] of src to column r.
  /// As a special case, if indexes[i] == -1, skip column i
  /// indices.size() must equal this->NumCols(),
  /// all elements of "reorder" must be in [-1, src.NumCols()-1],
  /// and src.NumRows() must equal this.NumRows()
  void AddCols(const MatrixBase<Real> &src,
               const MatrixIndexT *indices);

  /// Copies row r of this matrix from an array of floats at the location given
  /// by src[r]. If any src[r] is NULL then this.Row(r) will be set to zero.
  /// Note: we are using "pointer to const pointer to const object" for "src",
  ///       because we may create "src" by calling Data() of const CuArray
  void CopyRows(const Real *const *src);

  /// Copies row r of this matrix to the array of floats at the location given
  /// by dst[r]. If dst[r] is NULL, does not copy anywhere.  Requires that none
  /// of the memory regions pointed to by the pointers in "dst" overlap (e.g.
  /// none of the pointers should be the same).
  void CopyToRows(Real *const *dst) const;

  /// Does for each row r, this.Row(r) += alpha * src.row(indexes[r]).
  /// If indexes[r] < 0, does not add anything. all elements of "indexes" must
  /// be in [-1, src.NumRows()-1], and src.NumCols() must equal this.NumCols().
  void AddRows(Real alpha,
               const MatrixBase<Real> &src,
               const MatrixIndexT *indexes);

  /// Does for each row r, this.Row(r) += alpha * src[r], treating src[r] as the
  /// beginning of a region of memory representing a vector of floats, of the
  /// same length as this.NumCols(). If src[r] is NULL, does not add anything.
  void AddRows(Real alpha, const Real *const *src);

  /// For each row r of this matrix, adds it (times alpha) to the array of
  /// floats at the location given by dst[r]. If dst[r] is NULL, does not do
  /// anything for that row. Requires that none of the memory regions pointed
  /// to by the pointers in "dst" overlap (e.g. none of the pointers should be
  /// the same).
  void AddToRows(Real alpha, Real *const *dst) const;

  /// For each row i of *this, adds this->Row(i) to
  /// dst->Row(indexes(i)) if indexes(i) >= 0, else do nothing.
  /// Requires that all the indexes[i] that are >= 0
  /// be distinct, otherwise the behavior is undefined.
  void AddToRows(Real alpha,
                 const MatrixIndexT *indexes,
                 MatrixBase<Real> *dst) const;

  inline void ApplyPow(Real power) {
    this -> Pow(*this, power);
  }

  inline void ApplyPowAbs(Real power, bool include_sign=false) {
    this -> PowAbs(*this, power, include_sign);
  }

  inline void ApplyHeaviside() {
    this -> Heaviside(*this);
  }

  inline void ApplyFloor(Real floor_val) {
    this -> Floor(*this, floor_val);
  }

  inline void ApplyCeiling(Real ceiling_val) {
    this -> Ceiling(*this, ceiling_val);
  }

  inline void ApplyExp() {
    this -> Exp(*this);
  }

  inline void ApplyExpSpecial() {
    this -> ExpSpecial(*this);
  }

  inline void ApplyExpLimited(Real lower_limit, Real upper_limit) {
    this -> ExpLimited(*this, lower_limit, upper_limit);
  }

  inline void ApplyLog() {
    this -> Log(*this);
  }

  /// Eigenvalue Decomposition of a square NxN matrix into the form (*this) = P D
  /// P^{-1}.  Be careful: the relationship of D to the eigenvalues we output is
  /// slightly complicated, due to the need for P to be real.  In the symmetric
  /// case D is diagonal and real, but in
  /// the non-symmetric case there may be complex-conjugate pairs of eigenvalues.
  /// In this case, for the equation (*this) = P D P^{-1} to hold, D must actually
  /// be block diagonal, with 2x2 blocks corresponding to any such pairs.  If a
  /// pair is lambda +- i*mu, D will have a corresponding 2x2 block
  /// [lambda, mu; -mu, lambda].
  /// Note that if the input matrix (*this) is non-invertible, P may not be invertible
  /// so in this case instead of the equation (*this) = P D P^{-1} holding, we have
  /// instead (*this) P = P D.
  ///
  /// The non-member function CreateEigenvalueMatrix creates D from eigs_real and eigs_imag.
  void Eig(MatrixBase<Real> *P,
           VectorBase<Real> *eigs_real,
           VectorBase<Real> *eigs_imag) const;

  /// The Power method attempts to take the matrix to a power using a method that
  /// works in general for fractional and negative powers.  The input matrix must
  /// be invertible and have reasonable condition (or we don't guarantee the
  /// results.  The method is based on the eigenvalue decomposition.  It will
  /// return false and leave the matrix unchanged, if at entry the matrix had
  /// real negative eigenvalues (or if it had zero eigenvalues and the power was
  /// negative).
  bool Power(Real pow);

  /** Singular value decomposition
     Major limitations:
     For nonsquare matrices, we assume m>=n (NumRows >= NumCols), and we return
     the "skinny" Svd, i.e. the matrix in the middle is diagonal, and the
     one on the left is rectangular.

     In Svd, *this = U*diag(S)*Vt.
     Null pointers for U and/or Vt at input mean we do not want that output.  We
     expect that S.Dim() == m, U is either NULL or m by n,
     and v is either NULL or n by n.
     The singular values are not sorted (use SortSvd for that).  */
  void DestructiveSvd(VectorBase<Real> *s, MatrixBase<Real> *U,
                      MatrixBase<Real> *Vt);  // Destroys calling matrix.

  /// Compute SVD (*this) = U diag(s) Vt.   Note that the V in the call is already
  /// transposed; the normal formulation is U diag(s) V^T.
  /// Null pointers for U or V mean we don't want that output (this saves
  /// compute).  The singular values are not sorted (use SortSvd for that).
  void Svd(VectorBase<Real> *s, MatrixBase<Real> *U,
           MatrixBase<Real> *Vt) const;
  /// Compute SVD but only retain the singular values.
  void Svd(VectorBase<Real> *s) const { Svd(s, NULL, NULL); }

  /// Returns smallest singular value.
  Real MinSingularValue() const {
    Vector<Real> tmp(std::min(NumRows(), NumCols()));
    Svd(&tmp);
    return tmp.Min();
  }

  void TestUninitialized() const; // This function is designed so that if any element
  // if the matrix is uninitialized memory, valgrind will complain.

  /// Returns condition number by computing Svd.  Works even if cols > rows.
  /// Returns infinity if all singular values are zero.
  Real Cond() const;

  /// Returns true if matrix is Symmetric.
  bool IsSymmetric(Real cutoff = 1.0e-05) const;  // replace magic number

  /// Returns true if matrix is Diagonal.
  bool IsDiagonal(Real cutoff = 1.0e-05) const;  // replace magic number

  /// Returns true if the matrix is all zeros, except for ones on diagonal.  (it
  /// does not have to be square).  More specifically, this function returns
  /// false if for any i, j, (*this)(i, j) differs by more than cutoff from the
  /// expression (i == j ? 1 : 0).
  bool IsUnit(Real cutoff = 1.0e-05) const;     // replace magic number

  /// Returns true if matrix is all zeros.
  bool IsZero(Real cutoff = 1.0e-05) const;     // replace magic number

  /// Frobenius norm, which is the sqrt of sum of square elements.  Same as Schatten 2-norm,
  /// or just "2-norm".
  Real FrobeniusNorm() const;

  /// Returns true if ((*this)-other).FrobeniusNorm()
  /// <= tol * (*this).FrobeniusNorm().
  bool ApproxEqual(const MatrixBase<Real> &other, float tol = 0.01) const;

  /// Tests for exact equality.  It's usually preferable to use ApproxEqual.
  bool Equal(const MatrixBase<Real> &other) const;

  /// largest absolute value.
  Real LargestAbsElem() const;  // largest absolute value.

  /// Returns log(sum(exp())) without exp overflow
  /// If prune > 0.0, it uses a pruning beam, discarding
  /// terms less than (max - prune).  Note: in future
  /// we may change this so that if prune = 0.0, it takes
  /// the max, so use -1 if you don't want to prune.
  Real LogSumExp(Real prune = -1.0) const;

  /// Apply soft-max to the collection of all elements of the
  /// matrix and return normalizer (log sum of exponentials).
  Real ApplySoftMax();
  void ApplySoftMaxPerRow();

  /// Set each element to the sigmoid of the corresponding element of "src".
  void Sigmoid(const MatrixBase<Real> &src);

  /// Sets each element to the Heaviside step function (x > 0 ? 1 : 0) of the
  /// corresponding element in "src".  Note: in general you can make different
  /// choices for x = 0, but for now please leave it as it (i.e. returning zero)
  /// because it affects the RectifiedLinearComponent in the neural net code.
  void Heaviside(const MatrixBase<Real> &src);

  void Exp(const MatrixBase<Real> &src);

  void Pow(const MatrixBase<Real> &src, Real power);

  void Log(const MatrixBase<Real> &src);

  /// Apply power to the absolute value of each element.
  /// If include_sign is true, the result will be multiplied with
  /// the sign of the input value.
  /// If the power is negative and the input to the power is zero,
  /// The output will be set zero. If include_sign is true, it will
  /// multiply the result by the sign of the input.
  void PowAbs(const MatrixBase<Real> &src, Real power, bool include_sign=false);

  void Floor(const MatrixBase<Real> &src, Real floor_val);

  void Ceiling(const MatrixBase<Real> &src, Real ceiling_val);

  /// For each element x of the matrix, set it to
  /// (x < 0 ? exp(x) : x + 1).  This function is used
  /// in our RNNLM training.
  void ExpSpecial(const MatrixBase<Real> &src);

  /// This is equivalent to running:
  /// Floor(src, lower_limit);
  /// Ceiling(src, upper_limit);
  /// Exp(src)
  void ExpLimited(const MatrixBase<Real> &src, Real lower_limit, Real upper_limit);

  /// Set each element to y = log(1 + exp(x))
  void SoftHinge(const MatrixBase<Real> &src);

  /// Apply the function y(i) = (sum_{j = i*G}^{(i+1)*G-1} x_j^(power))^(1 / p).
  /// Requires src.NumRows() == this->NumRows() and  src.NumCols() % this->NumCols() == 0.
  void GroupPnorm(const MatrixBase<Real> &src, Real power);

  /// Calculate derivatives for the GroupPnorm function above...
  /// if "input" is the input to the GroupPnorm function above (i.e. the "src" variable),
  /// and "output" is the result of the computation (i.e. the "this" of that function
  /// call), and *this has the same dimension as "input", then it sets each element
  /// of *this to the derivative d(output-elem)/d(input-elem) for each element of "input", where
  /// "output-elem" is whichever element of output depends on that input element.
  void GroupPnormDeriv(const MatrixBase<Real> &input, const MatrixBase<Real> &output,
                       Real power);

  /// Apply the function y(i) = (max_{j = i*G}^{(i+1)*G-1} x_j
  /// Requires src.NumRows() == this->NumRows() and  src.NumCols() % this->NumCols() == 0.
  void GroupMax(const MatrixBase<Real> &src);

  /// Calculate derivatives for the GroupMax function above, where
  /// "input" is the input to the GroupMax function above (i.e. the "src" variable),
  /// and "output" is the result of the computation (i.e. the "this" of that function
  /// call), and *this must have the same dimension as "input". Each element
  /// of *this will be set to 1 if the corresponding input equals the output of
  /// the group, and 0 otherwise. The equals the function derivative where it is
  /// defined (it's not defined where multiple inputs in the group are equal to the output).
  void GroupMaxDeriv(const MatrixBase<Real> &input, const MatrixBase<Real> &output);

  /// Set each element to the tanh of the corresponding element of "src".
  void Tanh(const MatrixBase<Real> &src);

  // Function used in backpropagating derivatives of the sigmoid function:
  // element-by-element, set *this = diff * value * (1.0 - value).
  void DiffSigmoid(const MatrixBase<Real> &value,
                   const MatrixBase<Real> &diff);

  // Function used in backpropagating derivatives of the tanh function:
  // element-by-element, set *this = diff * (1.0 - value^2).
  void DiffTanh(const MatrixBase<Real> &value,
                const MatrixBase<Real> &diff);

  /** Uses Svd to compute the eigenvalue decomposition of a symmetric positive
   * semi-definite matrix: (*this) = rP * diag(rS) * rP^T, with rP an
   * orthogonal matrix so rP^{-1} = rP^T.   Throws exception if input was not
   * positive semi-definite (check_thresh controls how stringent the check is;
   * set it to 2 to ensure it won't ever complain, but it will zero out negative
   * dimensions in your matrix.
   *
   * Caution: if you want the eigenvalues, it may make more sense to convert to
   * SpMatrix and use Eig() function there, which uses eigenvalue decomposition
   * directly rather than SVD.
  */
  void SymPosSemiDefEig(VectorBase<Real> *s, MatrixBase<Real> *P,
                        Real check_thresh = 0.001);

  // There are some weird issue with template friend function in a class
  // template in Windows version of nvcc. This is simple an ugly walkaround.
#if defined(__NVCC__) && defined(_MSC_VER)
  template<typename Real>
#endif
  friend Real kaldi::TraceMatMat<Real>(const MatrixBase<Real> &A,
      const MatrixBase<Real> &B, MatrixTransposeType trans);  // tr (A B)

  // so it can get around const restrictions on the pointer to data_.
  friend class SubMatrix<Real>;

  /// Add a scalar to each element
  void Add(const Real alpha);

  /// Add a scalar to each diagonal element.
  void AddToDiag(const Real alpha);

  /// *this += alpha * a * b^T
  template<typename OtherReal>
  void AddVecVec(const Real alpha, const VectorBase<OtherReal> &a,
                 const VectorBase<OtherReal> &b);

  /// [each row of *this] += alpha * v
  template<typename OtherReal>
  void AddVecToRows(const Real alpha, const VectorBase<OtherReal> &v);

  /// [each col of *this] += alpha * v
  template<typename OtherReal>
  void AddVecToCols(const Real alpha, const VectorBase<OtherReal> &v);

  /// *this += alpha * M [or M^T]
  void AddMat(const Real alpha, const MatrixBase<Real> &M,
              MatrixTransposeType transA = kNoTrans);

  /// *this += alpha * A [or A^T].
  void AddSmat(Real alpha, const SparseMatrix<Real> &A,
               MatrixTransposeType trans = kNoTrans);

  /// (*this) = alpha * op(A) * B + beta * (*this), where A is sparse.
  /// Multiplication of sparse with dense matrix.  See also AddMatSmat.
  void AddSmatMat(Real alpha, const SparseMatrix<Real> &A,
                  MatrixTransposeType transA, const MatrixBase<Real> &B,
                  Real beta);

  /// (*this) = alpha * A * op(B) + beta * (*this), where B is sparse
  /// and op(B) is either B or trans(B) depending on the 'transB' argument.
  /// This is multiplication of a dense by a sparse matrix.  See also
  /// AddSmatMat.
  void AddMatSmat(Real alpha, const MatrixBase<Real> &A,
                  const SparseMatrix<Real> &B, MatrixTransposeType transB,
                  Real beta);

  /// *this = beta * *this + alpha * M M^T, for symmetric matrices.  It only
  /// updates the lower triangle of *this.  It will leave the matrix asymmetric;
  /// if you need it symmetric as a regular matrix, do CopyLowerToUpper().
  void SymAddMat2(const Real alpha, const MatrixBase<Real> &M,
                  MatrixTransposeType transA, Real beta);

  /// *this = beta * *this + alpha * diag(v) * M [or M^T].
  /// The same as adding M but scaling each row M_i by v(i).
  void AddDiagVecMat(const Real alpha, const VectorBase<Real> &v,
                     const MatrixBase<Real> &M, MatrixTransposeType transM,
                     Real beta = 1.0);

  /// *this = beta * *this + alpha * M [or M^T] * diag(v)
  /// The same as adding M but scaling each column M_j by v(j).
  void AddMatDiagVec(const Real alpha,
                     const MatrixBase<Real> &M, MatrixTransposeType transM,
                     VectorBase<Real> &v,
                     Real beta = 1.0);

  /// *this = beta * *this + alpha * A .* B (.* element by element multiplication)
  void AddMatMatElements(const Real alpha,
                         const MatrixBase<Real>& A,
                         const MatrixBase<Real>& B,
                         const Real beta);

  /// *this += alpha * S
  template<typename OtherReal>
  void AddSp(const Real alpha, const SpMatrix<OtherReal> &S);

  void AddMatMat(const Real alpha,
                 const MatrixBase<Real>& A, MatrixTransposeType transA,
                 const MatrixBase<Real>& B, MatrixTransposeType transB,
                 const Real beta);

  /// *this = a * b / c (by element; when c = 0, *this = a)
  void SetMatMatDivMat(const MatrixBase<Real>& A,
                       const MatrixBase<Real>& B,
                       const MatrixBase<Real>& C);

  /// A version of AddMatMat specialized for when the second argument
  /// contains a lot of zeroes.
  void AddMatSmat(const Real alpha,
                  const MatrixBase<Real>& A, MatrixTransposeType transA,
                  const MatrixBase<Real>& B, MatrixTransposeType transB,
                  const Real beta);

  /// A version of AddMatMat specialized for when the first argument
  /// contains a lot of zeroes.
  void AddSmatMat(const Real alpha,
                  const MatrixBase<Real>& A, MatrixTransposeType transA,
                  const MatrixBase<Real>& B, MatrixTransposeType transB,
                  const Real beta);

  /// this <-- beta*this + alpha*A*B*C.
  void AddMatMatMat(const Real alpha,
                    const MatrixBase<Real>& A, MatrixTransposeType transA,
                    const MatrixBase<Real>& B, MatrixTransposeType transB,
                    const MatrixBase<Real>& C, MatrixTransposeType transC,
                    const Real beta);

  /// this <-- beta*this + alpha*SpA*B.
  // This and the routines below are really
  // stubs that need to be made more efficient.
  void AddSpMat(const Real alpha,
                const SpMatrix<Real>& A,
                const MatrixBase<Real>& B, MatrixTransposeType transB,
                const Real beta) {
    Matrix<Real> M(A);
    return AddMatMat(alpha, M, kNoTrans, B, transB, beta);
  }
  /// this <-- beta*this + alpha*A*B.
  void AddTpMat(const Real alpha,
                const TpMatrix<Real>& A, MatrixTransposeType transA,
                const MatrixBase<Real>& B, MatrixTransposeType transB,
                const Real beta) {
    Matrix<Real> M(A);
    return AddMatMat(alpha, M, transA, B, transB, beta);
  }
  /// this <-- beta*this + alpha*A*B.
  void AddMatSp(const Real alpha,
                const MatrixBase<Real>& A, MatrixTransposeType transA,
                const SpMatrix<Real>& B,
                const Real beta) {
    Matrix<Real> M(B);
    return AddMatMat(alpha, A, transA, M, kNoTrans, beta);
  }
  /// this <-- beta*this + alpha*A*B*C.
  void AddSpMatSp(const Real alpha,
                  const SpMatrix<Real> &A,
                  const MatrixBase<Real>& B, MatrixTransposeType transB,
                  const SpMatrix<Real>& C,
                const Real beta) {
    Matrix<Real> M(A), N(C);
    return AddMatMatMat(alpha, M, kNoTrans, B, transB, N, kNoTrans, beta);
  }
  /// this <-- beta*this + alpha*A*B.
  void AddMatTp(const Real alpha,
                const MatrixBase<Real>& A, MatrixTransposeType transA,
                const TpMatrix<Real>& B, MatrixTransposeType transB,
                const Real beta) {
    Matrix<Real> M(B);
    return AddMatMat(alpha, A, transA, M, transB, beta);
  }

  /// this <-- beta*this + alpha*A*B.
  void AddTpTp(const Real alpha,
               const TpMatrix<Real>& A, MatrixTransposeType transA,
               const TpMatrix<Real>& B, MatrixTransposeType transB,
               const Real beta) {
    Matrix<Real> M(A), N(B);
    return AddMatMat(alpha, M, transA, N, transB, beta);
  }

  /// this <-- beta*this + alpha*A*B.
  // This one is more efficient, not like the others above.
  void AddSpSp(const Real alpha,
               const SpMatrix<Real>& A, const SpMatrix<Real>& B,
               const Real beta);

  /// Copy lower triangle to upper triangle (symmetrize)
  void CopyLowerToUpper();

  /// Copy upper triangle to lower triangle (symmetrize)
  void CopyUpperToLower();

  /// This function orthogonalizes the rows of a matrix using the Gram-Schmidt
  /// process.  It is only applicable if NumRows() <= NumCols().  It will use
  /// random number generation to fill in rows with something nonzero, in cases
  /// where the original matrix was of deficient row rank.
  void OrthogonalizeRows();

  /// stream read.
  /// Use instead of stream<<*this, if you want to add to existing contents.
  // Will throw exception on failure.
  void Read(std::istream & in, bool binary, bool add = false);
  /// write to stream.
  void Write(std::ostream & out, bool binary) const;

  // Below is internal methods for Svd, user does not have to know about this.
#if !defined(HAVE_ATLAS) && !defined(USE_KALDI_SVD)
  // protected:
  // Should be protected but used directly in testing routine.
  // destroys *this!
  void LapackGesvd(VectorBase<Real> *s, MatrixBase<Real> *U,
                     MatrixBase<Real> *Vt);
#else
 protected:
  // destroys *this!
  bool JamaSvd(VectorBase<Real> *s, MatrixBase<Real> *U,
               MatrixBase<Real> *V);

#endif
 protected:

  ///  Initializer, callable only from child.
  explicit MatrixBase(Real *data, MatrixIndexT cols, MatrixIndexT rows, MatrixIndexT stride) :
    data_(data), num_cols_(cols), num_rows_(rows), stride_(stride) {
    KALDI_ASSERT_IS_FLOATING_TYPE(Real);
  }

  ///  Initializer, callable only from child.
  /// Empty initializer, for un-initialized matrix.
  explicit MatrixBase(): data_(NULL) {
    KALDI_ASSERT_IS_FLOATING_TYPE(Real);
  }

  // Make sure pointers to MatrixBase cannot be deleted.
  ~MatrixBase() { }

  /// A workaround that allows SubMatrix to get a pointer to non-const data
  /// for const Matrix. Unfortunately C++ does not allow us to declare a
  /// "public const" inheritance or anything like that, so it would require
  /// a lot of work to make the SubMatrix class totally const-correct--
  /// we would have to override many of the Matrix functions.
  inline Real*  Data_workaround() const {
    return data_;
  }

  /// data memory area
  Real*   data_;

  /// these attributes store the real matrix size as it is stored in memory
  /// including memalignment
  MatrixIndexT    num_cols_;   /// < Number of columns
  MatrixIndexT    num_rows_;   /// < Number of rows
  /** True number of columns for the internal matrix. This number may differ
   * from num_cols_ as memory alignment might be used. */
  MatrixIndexT    stride_;
 private:
  KALDI_DISALLOW_COPY_AND_ASSIGN(MatrixBase);
};

/// A class for storing matrices.
template<typename Real>
class Matrix : public MatrixBase<Real> {
 public:

  /// Empty constructor.
  Matrix();

  /// Basic constructor.
  Matrix(const MatrixIndexT r, const MatrixIndexT c,
         MatrixResizeType resize_type = kSetZero,
         MatrixStrideType stride_type = kDefaultStride):
      MatrixBase<Real>() { Resize(r, c, resize_type, stride_type); }

  /// Copy constructor from CUDA matrix
  /// This is defined in ../cudamatrix/cu-matrix.h
  template<typename OtherReal>
  explicit Matrix(const CuMatrixBase<OtherReal> &cu,
                  MatrixTransposeType trans = kNoTrans);

  /// Swaps the contents of *this and *other.  Shallow swap.
  void Swap(Matrix<Real> *other);

  /// Defined in ../cudamatrix/cu-matrix.cc
  void Swap(CuMatrix<Real> *mat);

  /// Constructor from any MatrixBase. Can also copy with transpose.
  /// Allocates new memory.
  explicit Matrix(const MatrixBase<Real> & M,
                  MatrixTransposeType trans = kNoTrans);

  /// Same as above, but need to avoid default copy constructor.
  Matrix(const Matrix<Real> & M);  //  (cannot make explicit)

  /// Copy constructor: as above, but from another type.
  template<typename OtherReal>
  explicit Matrix(const MatrixBase<OtherReal> & M,
                    MatrixTransposeType trans = kNoTrans);

  /// Copy constructor taking SpMatrix...
  /// It is symmetric, so no option for transpose, and NumRows == Cols
  template<typename OtherReal>
  explicit Matrix(const SpMatrix<OtherReal> & M) : MatrixBase<Real>() {
    Resize(M.NumRows(), M.NumRows(), kUndefined);
    this->CopyFromSp(M);
  }

  /// Constructor from CompressedMatrix
  explicit Matrix(const CompressedMatrix &C);

  /// Copy constructor taking TpMatrix...
  template <typename OtherReal>
  explicit Matrix(const TpMatrix<OtherReal> & M,
                  MatrixTransposeType trans = kNoTrans) : MatrixBase<Real>() {
    if (trans == kNoTrans) {
      Resize(M.NumRows(), M.NumCols(), kUndefined);
      this->CopyFromTp(M);
    } else {
      Resize(M.NumCols(), M.NumRows(), kUndefined);
      this->CopyFromTp(M, kTrans);
    }
  }

  /// read from stream.
  // Unlike one in base, allows resizing.
  void Read(std::istream & in, bool binary, bool add = false);

  /// Remove a specified row.
  void RemoveRow(MatrixIndexT i);

  /// Transpose the matrix.  Works for non-square
  /// matrices as well as square ones.
  void Transpose();

  /// Distructor to free matrices.
  ~Matrix() { Destroy(); }

  /// Sets matrix to a specified size (zero is OK as long as both r and c are
  /// zero).  The value of the new data depends on resize_type:
  ///   -if kSetZero, the new data will be zero
  ///   -if kUndefined, the new data will be undefined
  ///   -if kCopyData, the new data will be the same as the old data in any
  ///      shared positions, and zero elsewhere.
  ///
  /// You can set stride_type to kStrideEqualNumCols to force the stride
  /// to equal the number of columns; by default it is set so that the stride
  /// in bytes is a multiple of 16.
  ///
  /// This function takes time proportional to the number of data elements.
  void Resize(const MatrixIndexT r,
              const MatrixIndexT c,
              MatrixResizeType resize_type = kSetZero,
              MatrixStrideType stride_type = kDefaultStride);

  /// Assignment operator that takes MatrixBase.
  Matrix<Real> &operator = (const MatrixBase<Real> &other) {
    if (MatrixBase<Real>::NumRows() != other.NumRows() ||
        MatrixBase<Real>::NumCols() != other.NumCols())
      Resize(other.NumRows(), other.NumCols(), kUndefined);
    MatrixBase<Real>::CopyFromMat(other);
    return *this;
  }

  /// Assignment operator. Needed for inclusion in std::vector.
  Matrix<Real> &operator = (const Matrix<Real> &other) {
    if (MatrixBase<Real>::NumRows() != other.NumRows() ||
        MatrixBase<Real>::NumCols() != other.NumCols())
      Resize(other.NumRows(), other.NumCols(), kUndefined);
    MatrixBase<Real>::CopyFromMat(other);
    return *this;
  }

 private:
  /// Deallocates memory and sets to empty matrix (dimension 0, 0).
  void Destroy();

  /// Init assumes the current class contents are invalid (i.e. junk or have
  /// already been freed), and it sets the matrix to newly allocated memory with
  /// the specified number of rows and columns.  r == c == 0 is acceptable.  The data
  /// memory contents will be undefined.
  void Init(const MatrixIndexT r,
            const MatrixIndexT c,
            const MatrixStrideType stride_type);

};
/// @} end "addtogroup matrix_group"

/// \addtogroup matrix_funcs_io
/// @{

/// A structure containing the HTK header.
/// [TODO: change the style of the variables to Kaldi-compliant]
struct HtkHeader {
  /// Number of samples.
  int32    mNSamples;
  /// Sample period.
  int32    mSamplePeriod;
  /// Sample size
  int16    mSampleSize;
  /// Sample kind.
  uint16   mSampleKind;
};

// Read HTK formatted features from file into matrix.
template<typename Real>
bool ReadHtk(std::istream &is, Matrix<Real> *M, HtkHeader *header_ptr);

// Write (HTK format) features to file from matrix.
template<typename Real>
bool WriteHtk(std::ostream &os, const MatrixBase<Real> &M, HtkHeader htk_hdr);

// Write (CMUSphinx format) features to file from matrix.
template<typename Real>
bool WriteSphinx(std::ostream &os, const MatrixBase<Real> &M);

/// @} end of "addtogroup matrix_funcs_io"

/**
  Sub-matrix representation.
  Can work with sub-parts of a matrix using this class.
  Note that SubMatrix is not very const-correct-- it allows you to
  change the contents of a const Matrix.  Be careful!
*/

template<typename Real>
class SubMatrix : public MatrixBase<Real> {
 public:
  // Initialize a SubMatrix from part of a matrix; this is
  // a bit like A(b:c, d:e) in Matlab.
  // This initializer is against the proper semantics of "const", since
  // SubMatrix can change its contents.  It would be hard to implement
  // a "const-safe" version of this class.
  SubMatrix(const MatrixBase<Real>& T,
            const MatrixIndexT ro,  // row offset, 0 < ro < NumRows()
            const MatrixIndexT r,   // number of rows, r > 0
            const MatrixIndexT co,  // column offset, 0 < co < NumCols()
            const MatrixIndexT c);   // number of columns, c > 0

  // This initializer is mostly intended for use in CuMatrix and related
  // classes.  Be careful!
  SubMatrix(Real *data,
            MatrixIndexT num_rows,
            MatrixIndexT num_cols,
            MatrixIndexT stride);

  ~SubMatrix<Real>() {}

  /// This type of constructor is needed for Range() to work [in Matrix base
  /// class]. Cannot make it explicit.
  SubMatrix<Real> (const SubMatrix &other):
  MatrixBase<Real> (other.data_, other.num_cols_, other.num_rows_,
                    other.stride_) {}

 private:
  /// Disallow assignment.
  SubMatrix<Real> &operator = (const SubMatrix<Real> &other);
};
/// @} End of "addtogroup matrix_funcs_io".

/// \addtogroup matrix_funcs_scalar
/// @{

// Some declarations.  These are traces of products.

template<typename Real>
bool ApproxEqual(const MatrixBase<Real> &A,
                 const MatrixBase<Real> &B, Real tol = 0.01) {
  return A.ApproxEqual(B, tol);
}

template<typename Real>
inline void AssertEqual(const MatrixBase<Real> &A, const MatrixBase<Real> &B,
                        float tol = 0.01) {
  KALDI_ASSERT(A.ApproxEqual(B, tol));
}

/// Returns trace of matrix.
template <typename Real>
double TraceMat(const MatrixBase<Real> &A) { return A.Trace(); }

/// Returns tr(A B C)
template <typename Real>
Real TraceMatMatMat(const MatrixBase<Real> &A, MatrixTransposeType transA,
                      const MatrixBase<Real> &B, MatrixTransposeType transB,
                      const MatrixBase<Real> &C, MatrixTransposeType transC);

/// Returns tr(A B C D)
template <typename Real>
Real TraceMatMatMatMat(const MatrixBase<Real> &A, MatrixTransposeType transA,
                         const MatrixBase<Real> &B, MatrixTransposeType transB,
                         const MatrixBase<Real> &C, MatrixTransposeType transC,
                         const MatrixBase<Real> &D, MatrixTransposeType transD);

/// @} end "addtogroup matrix_funcs_scalar"

/// \addtogroup matrix_funcs_misc
/// @{

/// Function to ensure that SVD is sorted.  This function is made as generic as
/// possible, to be applicable to other types of problems.  s->Dim() should be
/// the same as U->NumCols(), and we sort s from greatest to least absolute
/// value (if sort_on_absolute_value == true) or greatest to least value
/// otherwise, moving the columns of U, if it exists, and the rows of Vt, if it
/// exists, around in the same way.  Note: the "absolute value" part won't matter
/// if this is an actual SVD, since singular values are non-negative.
template<typename Real> void SortSvd(VectorBase<Real> *s, MatrixBase<Real> *U,
                                     MatrixBase<Real>* Vt = NULL,
                                     bool sort_on_absolute_value = true);

/// Creates the eigenvalue matrix D that is part of the decomposition used Matrix::Eig.
/// D will be block-diagonal with blocks of size 1 (for real eigenvalues) or 2x2
/// for complex pairs.  If a complex pair is lambda +- i*mu, D will have a corresponding
/// 2x2 block [lambda, mu; -mu, lambda].
/// This function will throw if any complex eigenvalues are not in complex conjugate
/// pairs (or the members of such pairs are not consecutively numbered).
template<typename Real>
void CreateEigenvalueMatrix(const VectorBase<Real> &real, const VectorBase<Real> &imag,
                            MatrixBase<Real> *D);

/// The following function is used in Matrix::Power, and separately tested, so we
/// declare it here mainly for the testing code to see.  It takes a complex value to
/// a power using a method that will work for noninteger powers (but will fail if the
/// complex value is real and negative).
template<typename Real>
bool AttemptComplexPower(Real *x_re, Real *x_im, Real power);

/// @} end of addtogroup matrix_funcs_misc

/// \addtogroup matrix_funcs_io
/// @{
template<typename Real>
std::ostream & operator << (std::ostream & Out, const MatrixBase<Real> & M);

template<typename Real>
std::istream & operator >> (std::istream & In, MatrixBase<Real> & M);

// The Matrix read allows resizing, so we override the MatrixBase one.
template<typename Real>
std::istream & operator >> (std::istream & In, Matrix<Real> & M);

template<typename Real>
bool SameDim(const MatrixBase<Real> &M, const MatrixBase<Real> &N) {
  return (M.NumRows() == N.NumRows() && M.NumCols() == N.NumCols());
}

/// @} end of \addtogroup matrix_funcs_io

}  // namespace kaldi

// we need to include the implementation and some
// template specializations.
#include "matrix/kaldi-matrix-inl.h"

#endif  // KALDI_MATRIX_KALDI_MATRIX_H_


text:
Q: $\overline{X\cap Y} \subseteq \overline{X} \cap \overline{Y}$
Let $X$ and $Y$ be two arbitrary subsets of $\mathbb{R}$. Show that $\overline{X\cap Y} \subseteq  \overline{X} \cap \overline{Y}$

Proof
since
$X\cap Y \subseteq X$ and $X\cap Y \subseteq Y$
$\implies \overline{X\cap Y} \subseteq \overline{X}$ and $\overline{X\cap Y} \subseteq \overline{Y}$
In other words, $\overline{X\cap Y}$ is present in both $\overline{X}$ and $\overline{Y}$.
$$\implies \overline{X\cap Y} \subseteq  \overline{X} \cap \overline{Y}$$
Is my proof correct?

A: Yes.
There's really not much more to say about it. The steps are trivial and clear. One might even regard the whole statement as obvious.

redpajama_set_name: RedPajamaStackExchange


7-Up is one of the many branded soft drinks, owned by PepsiCo, which people usually have because it does not contain any caffeine and it has a lemon-lime taste that everybody loves. Teenagers or little adults enjoy drinking 7-Up mainly because of its refreshing taste and cooling effects especially when consumed cold and with lots of ice. It was in 1929 when Charles Leiper Grigg introduced this famous drink. This Lemon-Lime soft drink is originally called "Bib-Label Lithiated Lemon-Lime Soda" that contains Lithium Nitrate. One of the original key ingredients of 7-Up is the Lithium Citrate which is used as a mood stabilizer in psychiatric treatments.
This drink was also a patented medicine marketed as a cure for hangover. In 1950, Lithium Citrate was removed and the product's name was changed to "7-Up". In 2006, it was re-formulated in the US so that it could be marketed as "100% Natural". As the brand starts expanding, major competitors began formulating their own brand such as the Coca-Cola Company and its product "Sprite", which was introduce in 1961. In 1980's, Coke forced all its major bottlers including Sprite to seriously challenge 7-Up's position and to decline 7-Up's distribution in deference to Sprite.
7-Up contest's Coke Company actions in court as "anti-competitive" but lost the case. 7-Up is known worldwide for its being 100% Natural Flavors and stripped off of artificial flavorings and preservatives. It has lots of cool flavors that people will enjoy. Some of these tastes are Cherry, Pomegranate, Raspberry, Orange and varieties of 7-Up's like 7-Up Ice Cola, 7-Up Free,7-Up Gold and 7-Up Plus. This beverage is not just something you would enjoy during hot sunny days. It can also be used in marinating and making sauces like what some famous chef said.


Twitch can be a strange and hilarious place - thanks to Twitch clips, many of the best and most bizarre moments are captured and enjoyed by millions of people around the world. Here are the top 10 most viewed Twitch clips of all time.
For the thousands of Twitch streamers around the world, a clip going viral and being shared all over the internet can be a blessing or a curse, depending on the contents of that clip.
If you're a smaller up-and-coming content creator, a clip getting millions of views could be the difference between 10 followers and 10,000 followers. However, it's almost impossible to predict what will and will not go viral.
This point was hammered home on January 28 when a clip of a sleeping streamer waking up to hundreds of viewers catapulted into the top 10 clips after just 24 hours, or when one of someone being scared senseless by his daughter sneaking up on him caught traction around two years after it was originally clipped.
Of course, you'll still see appearances from some of the world's most popular streamers, like Ninja or Dr Disrespect. Some clips will also be deleted and removed before they get the chance to become truly viral on Twitch's platform.
With all of this in mind, the top 10 most viewed Twitch clips of all time - according to Twitch Strike - can be found below. This list is accurate as of January 29 2019.


text:
Abortions for older women more common than for teens for first time in a decade
The change has been blamed on cuts in services
Alice Cachia
Women in their late thirties in Devon are more likely to have an abortion than those in their teens - for the first time in at least a decade.
New data has revealed one in every 175 women aged 35 or over in the area had an abortion in 2017. That compares with one in every 200 girls under the age 18.
It is the first time the rate for older women has been higher than that for teenagers in at least 10 years, according to data from the Department of Health and Social Care.
In 2007, one in every 59 teenage girls aged under 18 had abortions in Devon, while just one in every 200 women aged 35 and over had terminations.
Experts warned the figures reflected cuts to contraception services that were disproportionately affecting older women.
Now watch these amazing Devon stories
How laundry on a washing line caused row
Ghost watches boy outside Devon mansion
Police not interested in cat acid attack
Shoplifters caught on CCTV and shamed
In Plymouth, girls aged under 18 still had a higher rate of abortion than older women with one in every 99 girls having terminations, compared to one in every 143 women aged 35 and older.
In the South West of England as a whole, though, women aged 35 and older were more likely to have abortions than girls under 18.
One in every 149 women aged 35 and over had terminations last year, compared with one in every 152 teenage girls under the age of 18.
Mum uses experience of discrimination to pen novel about teen pregnancy
Regional records go as far back as 2004, when one in every 67 girls aged under 18 had terminations in the year - while one in every 167 women aged 35 and over also had abortions.
Figures show that nationally, women aged 35 and over had a higher rate of terminations than girls aged under 18 in the country - for the first time since modern records began.
One in every 118 women aged 35 and over had abortions in 2017, more than the one in every 122 girls aged under 18 who did the same.
A spokesperson for the British Pregnancy Advisory Service said: "It is not surprising to see a slight increase in the number of women over 35 accessing abortion services, in light of cuts to contraceptive services.
"There is concern that older women are the worst affected.
"Efforts to reduce teenage conception rates have resulted in a steep decline since 2005, but the needs of older women are sometimes neglected, and we know that there is an unmet need for contraceptive care among these older groups.
Juries with women more likely to convict people of sex offences, major study finds
"It is vital we ensure women of all ages have swift, local access to contraceptive services. Funding for family planning clinics must be secured, and barriers that impede women's access must be removed, such as the clinically unnecessary, mandatory consultation when purchasing emergency contraception – which puts women off, and drives up the price.
"We must also ensure that women have good access to abortion care throughout their reproductive lifetimes. No method of contraception is 100% effective, and more than half the women seeking a termination at BPAS last year were using contraception when they conceived.
"Contrary to popular belief, women can face an unplanned pregnancy well into their 40s.
"Their need for contraception and abortion care must not be neglected."

redpajama_set_name: RedPajamaCommonCrawl


If you are suffering from Seasonal Affective Disorder, then you need Bluewave light therapy. Seasonal Affective Disorder (or SAD as it is commonly known) affects people in climates where they do not see the sun much. It affects people more in winter months where the days are shorter and there is snow/rain/clouds, so the sun is not out.
This type of seasonal depression can be greatly helped with the use of bluewave light lamps. The use of these home devices substitutes for the natural sun in stimulating the pineal gland, which is housed behind the forehead, and regulates the production of seratonin and melatonin and sleep. Our body's natural circadian rhythm relies on the stimulation of this gland to regulate normal functions and when sunlight is deprived, some people suffer depression terribly. This can be helped with a aid of this amazing device.


text:
/**
 * Screen
 * @param {Object} __window__
 */

Screen = function(__window__){

    var $availHeight  = 600,
        $availWidth   = 800,
        $colorDepth   = 16,
        $pixelDepth   = 24,
        $height       = 600,
        $width        = 800,
        $top          = 0,
        $left         = 0,
        $availTop     = 0,
        $availLeft    = 0;

    __extend__( __window__, {
        moveBy : function(dx,dy){
            //TODO - modify $locals to reflect change
        },
        moveTo : function(x,y) {
            //TODO - modify $locals to reflect change
        },
        /*print : function(){
            //TODO - good global to modify to ensure print is not misused
        };*/
        resizeBy : function(dw, dh){
            __window__resizeTo($width + dw, $height + dh);
        },
        resizeTo : function(width, height){
            $width = (width <= $availWidth) ? width : $availWidth;
            $height = (height <= $availHeight) ? height : $availHeight;
        },
        scroll : function(x,y){
            //TODO - modify $locals to reflect change
        },
        scrollBy : function(dx, dy){
            //TODO - modify $locals to reflect change
        },
        scrollTo : function(x,y){
            //TODO - modify $locals to reflect change
        }
    });

    return {
        get top(){
            return $top;
        },
        get left(){
            return $left;
        },
        get availTop(){
            return $availTop;
        },
        get availLeft(){
            return $availLeft;
        },
        get availHeight(){
            return $availHeight;
        },
        get availWidth(){
            return $availWidth;
        },
        get colorDepth(){
            return $colorDepth;
        },
        get pixelDepth(){
            return $pixelDepth;
        },
        get height(){
            return $height;
        },
        get width(){
            return $width;
        }
    };
};


A three-year program offering unprecedented training experiences for complex pelvic floor reconstruction and opportunities to conduct cutting-edge translational research.
The Female Pelvic Medicine and Reconstructive Surgery (FPMRS) Fellowship is a three-year subspecialty training program for obstetrics and gynecology physicians and a two-year program for urology physicians who wish to specialize in urogynecology and reconstructive pelvic surgery.
The program includes 12 months of research.
In addition, opportunities for cutting-edge translational research are provided by the Wake Forest Institute for Regenerative Medicine.
The FPMRS Fellowship program teaches genitourinary physician-scientists the integrity, creativity and technical skills to deliver safe, efficient and effective care to all patients with pelvic floor disorders. Our educational curriculum is designed to enhance independence through mastery of a broad range of diagnostic and surgical techniques with proficiency in continuous quality improvement and team leadership skills.
Three board-certified urogynecologists, Catherine A. Matthews, MD, Candace Y. Parker-Autry, MD and Samuel S. Lentz, MD; and two urologists, Gopal H. Badlani, MD and Robert J. Evans, MD with extensive expertise in female urology serve as the primary faculty.
The fellowship is accredited by the Accreditation Council for Graduate Medical Education.
Introduce and then reinforce the acquisition of both basic and advanced surgical techniques through repetitive mentored practice, simulation and documentation of appropriate metrics.
Fellows are evaluated on both their activities and progress. Throughout the fellowship, you'll keep records detailing clinical experience, educational activities and research exposure. These are reviewed with you on a monthly basis, at which time you'll be given feedback regarding your performance, as well as an opportunity to critique your educational experience.
With specialists in both adult and pediatric urology, our faculty is experienced in training the complete range of urologic conditions and diseases, from stones and sexual dysfunction to prostate cancer, incontinence and infertility.


text:
Former grade II motor showroom is BCO finalist
April 2017 | News
Customer science company dunnhumby's headquarters, Shepherd's Bush Road, delivered by LOM architecture and design, is a finalist in this year's British Council for Offices' (BCO) awards Fit Out of Workplace category in the London and South East region.
The 10,861sqm bespoke headquarters, a conversion of a grade II listed former car showroom, blends early 20th century gentility with modern day working practices for dunnhumby's data savvy staff and is a destination for the company's prestigious clients. LOM worked together with Gensler at concept stage, and then supported dunnhumby in designing and delivering the project through to completion.
Established in 1992, the BCO awards provide public recognition, celebrate excellence and acknowledge best practice and innovation in office space. The London and South East winners will be announced on 25 April 2017 at the awards ceremony taking place at the Hilton on Park Lane.


Salomon 'Sally' Sorowitsch: Ich bin ich. Die anderen sind die anderen.
I came away with a moral dilemma of my own: though "The Counterfeiters" is excellent in places in others it is not.
The true story of Operation Bernhard and the printing of millions of pounds is a fascinating story. The direction, acting, and script are excellent. But my problem was one that for me was a real shock: I was not as moved by the film as I had hoped or wanted to be.
Dealing with the most singular piece of evil devised by man - genocide, especially in the concentration camps is never an easy subject, and perhaps the fact that it is not overplayed is a bonus - however, I came away admiring the film and its performances but left curiously unmoved by the overall tone of the piece.
Perhaps that's the point of the moral dichotomy (Make money, help the Nazis, don't make money, lose your lives but shorten the war) that is does not scream but rather affects us quietly.
Overall, definitely watchable. But misses greatness.


text:
Conservative-run Herts County Council hikes council tax
Hertfordshire Conservative County Councillors have voted through a Council tax increase of 1.99%, the maximum they can increase the tax by without taking it to a county-wide referendum.
In a highly controversial budget Hertfordshire Conservatives have proposed widespread cuts which will include buses and library services.
The Conservative-run council has rejected the Coalition Government's offer of £5.2m of extra funding if it did not increase the council tax.
The council tax raise and cuts to services will mean that the Conservative-run council will now be able to increase its reserves of money for a "rainy day" from £146m to £154m. They Conservative-run council also has a current collection round surplus of £5.9m.
Leader of the Opposition and the Liberal Democrat Group, Stephen Giles-Medhurst commented: "I am appalled. The County Council clearly has to be careful and look after taxpayers' money properly, but right now putting up council tax by almost 2 percent and also hitting services to the elderly and vulnerable leave a bad taste in the mouth. We all know
times are tough, but the Liberal Democrat Group have looked long and hard at the options available to us and we proposed an alternative budget that ring-fences essential services, restores cuts and freezes council tax whilst cutting waste and non-essential spending, and maximising income."
Included within the Liberal Democrat budget amendment was an extra £4.4m revenue spend that reversed cuts to mobile library services, buses, and school crossing patrols, allowed for councillors to restore street lights at night, ensured the gritting of roads outside schools, money for school uniforms for families in need, and also the extension of the apprenticeships scheme. On the capitalside, the Liberal Democrats proposed £2m for a new food relief programme, an extra £6m for highways and foot-way repairs and an extra £1.5m on a schools maintenance programme; all without increasing the council tax.
The Liberal Democrat budget amendment was lost and in a surprise move the smaller Labour Group refused to support it.
Paul Zukowskyj, Liberal Democrat Finance and Regeneration spokesperson said "I am appalled that the Conservative administration is seeking to impose a tax increase on the people of Hertfordshire whilst refusing Government funding of over £5m to freeze the council tax. This year HCC Conservatives have decided they would rather raise the council tax by as much as they can while slashing services - perhaps because it's a General Election year they hope their tax rise will go unnoticed!"
Stephen Giles-Medhurst added: "Perhaps they are putting money away to save up to try to cut the council tax in two years time before the next County elections - we will see."


text:
Q: How to get Original Size of Uploaded Image in Fabric js? First, add Uploaded image in the Canvas.
Second, Extract that same image from canvas and use toDataURL on that image object .
Problem : I can't find the same image that was uploaded.


text:
Q: Using the ASP.NET AJAX UpdatePanel with output caching Is there a way to have the UpdatePanel control play nicely with output caching?  I'd like to cache an entire ASP.NET page using the @OutputCache directive, EXCEPT for the UpdatePanel area.

A: Have you looked at the asp:substitution control?
http://msdn.microsoft.com/en-us/library/ms228212(v=vs.100).aspx


text:
Ship Stands
Aftermarket Woodwork
For Canadian Customers
We ship to the US and Canada! Free shipping on orders more than $150
Quick order form for fittings and other smal things...
Cannon Barrels (4 pcs) - 23/32" (19 mm) - CN00190 $3.49 USD
Cannon Barrels (4 pcs) - 1 7/64" (28 mm) - CN00280 $3.99 USD
Single block (10 pcs) - 5/64" (2.0 mm) - BL01020 $2.19 USD
Single block (10 pcs) - 1/8" (3.0 mm) - BL01030 $2.19 USD
Binnacle - BN02210 $4.99 USD
Double block (10 pcs) - 3/32" (2.5 mm) - BL02025 $2.19 USD
Double block (10 pcs) - 1/8" (3.0 mm) - BL02030 $2.19 USD
Windlass - 1 5/8" (42mm) - WL00420 $4.99 USD
Windlass - 2 7/16" (62 mm) - WL01620 $4.99 USD
Anchors (2pcs) - 1 1/4" (32 mm) - AN00320 $4.99 USD
Anchors (2pcs) - 1 9/16" (40 mm) - AN00400 $5.49 USD
Pump (2 pcs) - PU00170 $3.99 USD
Cleats - 19/64" (7.5mm) / 8 - CL00075 $1.59 USD
Triple block (10 pcs) - 1/8" (3.0 mm) - BL03030 $2.29 USD
Triple block (10 pcs) - 5/32" (4.0 mm) - BL03040 $2.49 USD
Capstan - CS00180 $4.99 USD
Review for Tender "Avos"
We have a very detailed review made by James Hatch of our newest addition - Tender "Avos".
store@craftysailor.com
Sign up for the latest news, and offers
Copyright © 2020, Crafty Sailor Model Store. This store is secured by


Welcome to the 9/11 WTC First Responders Foundation Informational Services domain Web site. The actual Domain name registered, the 911wtcfirstrespondersfoundation.org is protected for security reasons. When typing or searching for the .org web site you are redirected to the security domain, post911wtc.com since October, 2009. This web service maintained by our main office will be updated daily as needed once the design is completed. It offers extended information to the First Responder, our members, supporters and to the general public. The web site will continuously be updated with information requested by our Responders. It is important for users to report any links that are not working properly. We are designing the ease for using this web service integrated with; interactive services, FAQ, the Foundation Forum, Live conference room with scheduled guest speakers that you can be a part of right from your desk top, our Informational cable Television "EYES ON YOU" TV Show (audience tickets free), a photo gallery which requires registration to view any photos installed, donated or shared by our members and much more.
The world has witnessed the truth of bravery and dedication by the men and women of ALL categories of the workforce who have responded from each of the 50 states in the United States of America. The Spirit of America was the driving force that inspired all of our First Responders to participate in the rescue, recovery and cleanup at the World Trade Center crime scene, on September 11th, 2001. During this National State of Emergency in a time of need, NYC counted on the Spirit of America which was exemplified by all of our First Responders giving their all to keep us safe. Un-thought-of with their tireless efforts prevailed, the maintaining order in each state, searching for survivors at each terrorist target location attacked, and keeping all of our cities functioning while faced with this horrific carnage. Not only are all of our brave First Responders faced with a family crisis filled with medical and financial hardships, that for some became fatal, our communities environment has been blemished as well. Since the release of medical and research lab reports, a probable cause of thousands of individuals may also be suffering medically if toxic exposures were immune system induced, resulting from the collapse of the towers. It has been recorded that the many; Law Enforcement, Fire Fighters, EMS, National Guards, Veterans of Armed Forces, Construction workers, Red Cross, and Civilians, that were duly engaged by active or volunteer services, are now experiencing a wide range of illnesses.
The 9/11 WTC First Responders Foundation strives to establish a relief fund for those First Responders and their families who assisted at the World Trade Center, Fresh Kill Landfill, Pennsylvania and Washington DC sites following the September 11th terrorist attacks and all other Homeland Disasters on American Soil, since the September 11, 2001 WTC disaster. The Foundation will generate and provide a criteria package for all eligible First Responders aiding the most serious medical status as priority one and descending to lower levels of illnesses and financial hardships with available funding as we grow and raise the funds needed for this new Not for Profit Foundation, which has been on the drawing board since 2009, broke ground with a mission and concept for its cause late 2010 and Incorporated early 2011 and will operate as a National Organization.
The 9/11 WTC First Responders Foundation will make provisions for creating a Widows & Orphan's fund, as well as education and awareness programs, that encourage the future of our children to obey and work with all Federal Government Departments, Armed Forces, Law Enforcement, Fire, and EMS laws that are enacted for our protection, following approval by the NYS Education Dept. The Foundation will also seek aid from grants, donors, medical and treatment professionals as well as pharmaceutical companies with benefit assistance. The Foundation seeks, instituting a plan for programs that will procure the needed grants and donations, for the required certification and training of responders and their families such as; support groups, symptom and diagnosis awareness, immune toxin testing awareness, nutritional needs, awareness of continuous immune system detoxification to battle induced toxins from exposure to dust at a disaster and also toxins that medications may cause while we become sick. We are also making provisions for National Preparedness Month; with seminars, to learn from the many professionals who are willing to assist such as Martial Artists for Mind, Body and Spirit, CPR, yoga exercise and basic meditation that sick responders can handle, defensive driving/awareness when to quit, peoples with disabilities awareness and rights or obtaining state privileged benefits.
The 9/11 WTC First Responders Foundation intends legislatively to seek sponsorship for new bills into Government for the enactment of law and/or to modify existing laws through our future planned subsidiary 501(c)(4) not for profit 9/11 WTC FRF ACTION. Our subsidiary shall fight for the protection of; the United States, Human Rights, the U.S. Constitution of America, the future of America's children, and a better Quality of Life as a result of gang and terrorist criminal acts, and does not preclude the protection for National Security Monitoring throughout the United States and helping to promote the Loyal Order of World Peace and the Preservation of Freedom. The Foundation shall continue to promote and support the common ground of recent laws enacted such as the HR847, S.1334, James Zadroga bill, Compensation and Health Care for First Responders that was paved by the tireless efforts of the Feal Good Foundation and other support organizations who continuously have been providing aid with their programs for our First Responders. Further, The 9/11 WTC First Responders Foundation intends to include in its mission, the same benefits and support to all American First Responders who supported America in Homeland Disaster situations by their participation.
The Foundation encourages the practice for the spirit of America by brotherhood among other organizations who have the same irrespective moral views of race creed or religion; Promoting social, moral and professional integrity for the members, supporters and community which pertains to the 9/11 WTC First Responders Foundation, the American Citizen of the United States and not contrary to our Federal Government by Laws. In addition, the Foundation will promote its members to practice the common grounds of Good Fellowship among all disabled First Responders and not to preclude our War Veterans who have dedicated their time to facilitate both, physically and financially the assistance to those that are less fortunate, who have requested help through relief aid programs from various organizations, donors or grant programs that shall be permitted by law and after funds have been generated, and available as fund raising events build the base for aid with all Not for Profit organizations.


text:
Alê Abreu (* 6. März 1971 in São Paulo, Brasilien) ist ein brasilianischer Filmregisseur und Drehbuchschreiber.

Leben
1993 veröffentlichte Alê Abreu seinen Debütkurzfilm Sírius auf dem Filmfestival Anima Mundi. Es war der einzige Zeichentrickfilm in diesem Jahr. Der Film gewann die Kategorie "Bester Film" beim Festival de Cine para Niños y Jovenes und wurde auf dem São Paulo International Film Festival sowie dem Hiroshima Kokusai Animation Festival gezeigt. 1998 folgte mit Espantalho sein zweiter Kurzanimationsfilm. Er gewann den dritten Platz beim Anima Mundi und den Regiepreis (Animation) beim  Brazilian Film Festival of Miami.  Außerdem war er beim ersten Grande Prêmio Cinema Brasil in der Kategorie Zeichentrickfilm nominiert. Sein Debüt-Langfilm folgte 2007 mit Garoto Cósmico. 2013 erschien Der Junge und die Welt. Der Film hatte seine Premiere auf dem Ottawa International Animation Festival. Für diesen Film erhielt er den Filmpreis für Kinderrechte des Unabhängigen FilmFest Osnabrücks sowie bei der Oscarverleihung 2016 seine erste Oscar-Nominierung in der Kategorie Bester animierter Spielfilm.

Filmografie
 1993: Sírius (Kurzfilm)
 1998: Espantalho (Kurzfilm)
 2007: Passo (Kurzfilm)
 2007: Garoto Cósmico
 2013:  Der Junge und die Welt (O Menino e o Mundo)

Weblinks
 Offizielle Website

Einzelnachweise

Brasilianer
Filmregisseur
Drehbuchautor
Geboren 1971
Mann

redpajama_set_name: RedPajamaWikipedia


Todd's Blanket is a free crochet pattern using a simple single crochet, paired with the very trendy, and popular jumbo weight yarn and US50/25mm hook!
I made this blanket for Todd for Valentine's Day this year. He has been wanting one of those arm knit blankets for about two years now, and I haven't made him one because of the crazy cost in yarn, and inconvenience in having to order online, but just before Valentine's Day, I found myself browsing around Michael's, and I came across jumbo weight yarn – woo!
The wool jumbo weight yarn looked really icky, so I actually purchased one of these Wild Child by Loops & Threads first. Here's a blooper photo – Shiloh supervising.
When I got the Wild Child home, I started arm knitting with it to see how much one worked up – 1.) I hate arm knitting; 2.) BOY would I need A LOT! But for my love, it was worth it. I went back to Michaels to get the rest that I needed, and they didn't have enough in stock. It really worked out better though because this particular yarn says "dry clean only", and I am not about that!
I found some Bernat Big Blanket yarn, which was still jumbo weight, and really soft, PLUS I have read sooo many wonderful things about Bernat Blanket Yarn, so I bought it! They didn't have much in stock (an ongoing issue), so I really had to play with my colors. Normally, I would make my rows even, colorwise, but I didn't really have enough yarn to leave some out, so the color changes were a little odd.
I hid this yarn and WIP in a large box we had at home, so Todd wouldn't notice (hehe), and when it was finished, I wrapped it up in the same box, and made him a sweet little Valentine's card!
He LOVED the blanket! And used it when we had some really cold Winter weather, but the only thing is that he is around 6 foot tall (which is 72″), and the blanket came out a little shorter than I would have liked to properly cover him (measuring only 53″). If I had had more time (since I was short, and the yarn was hard to come by), I would have added two more balls of yarn. As is, it's a good couch blanket.
Are you a Raveler? Share your version of this project on Ravelry – Todd's Blanket.
I think as a yarn alternative, you could use two strands of the regular Bernat Blanket Yarn held together.
Usually, I use a smaller crochet hook to weave in my ends on bulky yarns, but with this one, I found it the easiest to just use my fingers.
I worked this blanket up in a few seatings for a total of just over 3 hours.
Rows 2 – 37: Chain 1, turn. SC into the 1st SC, and each across.
Please feel free to make and sell your own Todd's Blanket using this pattern, but please DO NOT claim this pattern as your own nor should you sell my pattern, and DO NOT re-publish my photos as your own. DO NOT copy and paste my pattern anywhere, link to it instead.
I love the neutral colors in that blanket and it looks oh, so soft!
Was trying to go for something that kind of matched our [mismatched] home. Have been trying to be more consistent though.
Looks so cozy! So funny about the blanket ending up short for him, the same thing happened with my husband, and even though that was years ago he still jokes about it…..I have since crocheted him a much larger blanket and made him a quilt fleece blanket, so I more than made up for that first one! Thanks so much for sharing on craft schooling Sunday!
Hehe. Happens to the best of us!
It looks so comfortable, I want to try out that yarn too. Thank you for sharing at The Really Crafty Link Party. Pinned.
It is a really fun yarn to try 🙂 It's sold exclusively at Michaels.


Gary L. Hamilton, 66, formerly of Charleroi, passed away on December 4, 2018. Born on August 18, 1952, he was the son of the late Francis and Dorothy Hamilton.
He was retired from Corning Glass/World Kitchen.
Gary is survived by his daughter, Lynn Hamilton, of Charleroi; and sister-in-law, Dolores Jean Michaux, of Charleroi.
In addition to his parents, he is predeceased by his wife, Maxine Lee Hamilton.
As per Gary's wishes, there will be no visitation or services.


text:
Bodies of 16 migrants recovered off Morocco coast
Sunday, February 04, 2018 — updated on July 03, 2020
At least 20 bodies have been pulled from the sea off the coast of Melilla, a small Spanish territory bordering Morocco. PHOTO | AFP
Moroccan rescue services recovered the corpses after the crew of a passenger ship spotted them in the water.
The dead are believed to be migrants from sub-Saharan Africa hoping to reach Europe.
NADOR, MOROCCO
Moroccan rescue services have recovered the bodies of 16 migrants off the coast of Spain's enclave of Melilla, Moroccan and Spanish officials said Sunday.
Three women were among the dead taken to a morgue in the Moroccan city of Nador, a medical official there told AFP.
News Feb 04, 2018
Education Feb 04, 2018
All were sub-Saharan Africans apart from one Moroccan, the official said.
A spokeswoman for Melilla's authorities earlier said "about 20" bodies had been recovered in Moroccan territorial waters.
The bodies of the migrants were spotted Saturday by a Spanish ship, which alerted the rescue services of both countries, she said.
Late Saturday, a Spanish police patrol boat found one more body, which was taken to Melilla, a Spanish enclave bordering Morocco.
Spanish authorities said a Civil Guard helicopter was supporting Moroccan search patrols on Sunday morning.
Migrants are increasingly favouring the so-called western Mediterranean route to reach Europe, which involves making the sea crossing between North Africa and southern mainland Spain.
According to the International Organization for Migration, Spain has been the second most popular point of entry for migrants coming to Europe so far this year, with 1,279 arrivals, after Italy with 4,256.
It said 243 people have died or are missing in the Mediterranean after trying to cross the sea this year, not including those recovered this weekend.
Spain was last year the third point of entry for Europe-bound migrants, after Italy and Greece.
Arrivals by sea tripled in 2017 compared to the previous year, reaching a total of 22,900 migrants, according to the EU border agency Frontex.
SEA CROSSING
According to Omar Naji, of the Moroccan Association of Human Rights, migrants have been making the sea crossing after authorities tightened controls at the Melilla border fence.
"Before more migrants would try to climb the Melilla fence...but now, after stricter controls, they can only cross from the sea," he told AFP.
Naji said that migrants must pay people smugglers 3,000 euros each to undertake the sea crossing "and this traffic is carried out before the eyes of the authorities".
Said Chramti, who heads the Grand Rif Human Rights association, told AFP that Europe is also responsible for the deaths of migrants because it is "tightening the screws on (illegal) migration".
He also criticised the Moroccan authorities for "failing in its battle against illegal migration networks".