景氣訊號

景氣指標查詢系統

2010年 11月分數是 32，從 3月～4月最高點漸漸滑下來，令人有點擔憂，反轉有那麼快嗎？就算擔心猶豫，也要勇敢做出決定，不做決定其實也是一種決定(常是錯誤決定)。

結論：審慎以對，該跑的時候用力跑(Signal:月成交量～5m)。

產業分析

周延的財報分析，必須建構在環境分析的基礎上。見樹不見林，賠錢剛剛好而已。

產業獲利能力決定於產業獲利潛力及相對議價能力。產業獲利潛力決定於競爭密度。競爭密度決定於現有競爭、潛在進入威脅及替代品威脅。廠商擁有兩種基本策略：成本領導與差異化。前者以價格取勝，後者以商品獨特性為訴求，兩者反應在財報上，會有顯著的不同。

財報分析之系統架構

廢話不多說，股票現金流 = 股利/(資金成本 - 股利成長性)。換言之，股票現金流與「(獲利-成長)/(風險-成長)」成正比，其中獲利最為重要。

以水管做比喻，獲利大等於水管大，風險等於漏水，成長等於水管大小變化率。不考慮資金成本，水管大先贏一半。

新台幣震盪

心理層面來說，一是很特別的數字，奇怪，彭老傻了嗎？快穩固呀！

其實彭老沒有傻，彭老已經告訴你「市場價」，看不懂？我沒辦法了。另外要注意邪惡美帝的QE3，個人認為是空包彈，喊喊而已。無論如何，美元正在貶值，但不要隨便接刀猜底，等底部確定趨勢反轉，再來尻美金吧。(當然，如果銀彈多(> 10E)，可以參考巴老作法，在恐慌的時候進場，逐步建立美金部位。)

PS1. 彭老BLOG多一篇新聞發布第264號：某位委員質詢「如果資金匯入多，央行不會堅守30元？」，楊副總裁係答復「資金進出頻繁時，匯率要有彈性」。還看不懂？那我也沒辦法了。

PS2. 新聞參考資料(99年11月消費者貸款及建築貸款餘額統計表)，趨勢還沒反轉，不要摸頭喔。

財報限制

限制1: 因會計資訊品質要求而衍生之限制
限制2: 因財務報表基本假設而衍生之限制
限制3: 因財務報表基本原則而衍生之限制

簡單說就是 trade-off. 在資訊領域裡, design 也是一種 trade-off. Trade-off 是選擇問題，不是對錯問題。

財報緒論

今天花錢買書投資自己，書是郭敏華寫的「財務報表分析評價應用」3rd，只要是不斷再版的書，都有其特殊價值。

概念1: 財報分析不只是分析財報。能夠分析企業價值，以及價值決定因子，才是真正的分析。

概念2: 哪些人看財報？知己知彼。權益投資人、債權投資人、供應商及顧客、管理當局與內部員工、政府。

概念3: 財務資訊的重要性。財報可以影響投資人決策(縱面、橫面、契約制定)，這影響取得資金成本，消費與投資配置，配置不同資源給上下游廠商(有好店家，也要有好顧客)，以及分配風險。

概念4: 資訊不對稱。發佈資訊可以獲得什麼效益？需要花多少成本發佈資訊？

整章精華就在「思考與分析」，該動動僵化的腦筋嘍。

Integrating Google C++ testing framework.

Adjust
1. C/C++ > General > Additional Include Directories and
2. Linker > Input > Additional Dependencies
3. C/C++ > Code Generation > Runtime Library to /MT (Release) or /MTd (Debug) according to the Gtest project's settings. Make sure their settings are EQUAL.


Finally, try to run the following sanity test:

#include 

int main(int argc, char** argv) {
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

Condition variable

A mutex is used to cause other threads to wait while the thread holding the mutex executes code in a critical section.

In contrast, a condition variable is typically used by a thread to make itself wait until an expression involving shared data attains a particular state.

在 POSIX-supported platform 上, 問題非常簡單, 有 pthread interface 可以用.

// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.                                                                                
class ConditionVariable {
 public:
  explicit ConditionVariable(Lock* user_lock);
  ~ConditionVariable();

  void Wait();
  void TimedWait(const base::TimeDelta& max_time);

  void Broadcast();
  void Signal();

 private:
  pthread_cond_t condition_;
  pthread_mutex_t* user_mutex_;
};

ConditionVariable::ConditionVariable(Lock* user_lock)
  : user_mutex_(user_lock->lock_.os_lock())
{
  pthread_cond_init(&condition_, NULL);
}

ConditionVariable::~ConditionVariable() {
  pthread_cond_destroy(&condition_);
}

void ConditionVariable::Wait() {
  pthread_cond_wait(&condition_, user_mutex_);
}

void ConditionVariable::TimedWait(const TimeDelta& max_time) {
  int64 usecs = max_time.InMicroseconds();

  // The timeout argument to pthread_cond_timedwait is in absolute time.
  struct timeval now;
  gettimeofday(&now, NULL);

  struct timespec abstime;
  abstime.tv_sec = now.tv_sec + (usecs / Time::kMicrosecondsPerSecond);
  abstime.tv_nsec = (now.tv_usec + (usecs % Time::kMicrosecondsPerSecond)) *
                    Time::kNanosecondsPerMicrosecond;
  abstime.tv_sec += abstime.tv_nsec / Time::kNanosecondsPerSecond;
  abstime.tv_nsec %= Time::kNanosecondsPerSecond;

  pthread_cond_timedwait(&condition_, user_mutex_, &abstime);
}

void ConditionVariable::Broadcast() {
  pthread_cond_broadcast(&condition_);
}

void ConditionVariable::Signal() {
  pthread_cond_signal(&condition_);
}

在 Windows platform 上, 雖然有新的 APIs: InitializeConditionVariable(), SleepConditionVariableCS(), SleepConditionVariableSRW(), WakeAllConditionVariable(), WakeConditionVariable(). 但舊的平台仍不支援，可憐的 programmer 得自己造輪子，或是用 3rd-party lib 來玩 cv.

先看 Windows platform 上 C++ class 怎麼表示他：

class ConditionVariable {
 public:
  ...
 private:
  class Event {
   public:
    Event();
    ~Event();

    void InitListElement();

    bool IsEmpty() const;
    void PushBack(Event* other);
    Event* PopFront();
    Event* PopBack();

    HANDLE handle() const;
    Event* Extract();

    bool IsSingleton() const;

   private:
    HANDLE handle_;
    Event* next_;
    Event* prev_;
  };

  // Note that RUNNING is an unlikely number to have in RAM by accident.
  // This helps with defensive destructor coding in the face of user error.
  enum RunState { SHUTDOWN = 0, RUNNING = 64213 };

  // Internal implementation methods supporting Wait().
  Event* GetEventForWaiting();
  void RecycleEvent(Event* used_event);

  RunState run_state_;

  // Private critical section for access to member data.
  Lock internal_lock_;

  // Lock that is acquired before calling Wait().
  Lock& user_lock_;

  // Events that threads are blocked on.
  Event waiting_list_;

  // Free list for old events.
  Event recycling_list_;
  int recycling_list_size_;
                                                                                
  // The number of allocated, but not yet deleted events.
  int allocation_counter_;
};

用 private class Event 來模擬 cv. Implementation 還挺複雜的，可以先看這篇文章: Strategies for Implementing POSIX Condition Variables on Win32. 難點在於: However, extreme care must be taken with Win32 events to ensure that there are no race conditions introduced when switching from one mechanism to another. Unfortunately, there's no way to release just one waiting thread with a manual-reset event. Likewise, there's no way to release all waiting threads with an auto-reset event.

Google implementation 簡單說就是用 create auto-reset event + SetEvent() + WaitForSingleObject()，現在來一一破解：

void ConditionVariable::Wait() {
  TimedWait(TimeDelta::FromMilliseconds(INFINITE));
}

void ConditionVariable::TimedWait(const TimeDelta& max_time) {
  Event* waiting_event;
  HANDLE handle;
  {
    AutoLock auto_lock(internal_lock_);
    if (RUNNING != run_state_) return;  // Destruction in progress.
    waiting_event = GetEventForWaiting();
    handle = waiting_event->handle();
  }  // Release internal_lock.

  {
    AutoUnlock unlock(user_lock_);  // Release caller's lock
    WaitForSingleObject(handle, static_cast(max_time.InMilliseconds()));
    // Minimize spurious signal creation window by recycling asap.
    AutoLock auto_lock(internal_lock_);
    RecycleEvent(waiting_event);
    // Release internal_lock_
  }  // Reacquire callers lock to depth at entry.
}

void ConditionVariable::Broadcast() {
  std::stack handles;  // See FAQ-question-10.
  {
    AutoLock auto_lock(internal_lock_);
    if (waiting_list_.IsEmpty())
      return;
    while (!waiting_list_.IsEmpty())
      // This is not a leak from waiting_list_.  See FAQ-question 12.
      handles.push(waiting_list_.PopBack()->handle());
  }  // Release internal_lock_.
  while (!handles.empty()) {
    SetEvent(handles.top());
    handles.pop();
  }
}

void ConditionVariable::Signal() {
  HANDLE handle;
  {
    AutoLock auto_lock(internal_lock_);
    if (waiting_list_.IsEmpty())
      return;  // No one to signal.
    // Only performance option should be used.
    // This is not a leak from waiting_list.  See FAQ-question 12.
    handle = waiting_list_.PopBack()->handle();  // LIFO.
  }  // Release internal_lock_.
  SetEvent(handle);
}

ConditionVariable::Event* ConditionVariable::GetEventForWaiting() {
  // We hold internal_lock, courtesy of Wait().
  Event* cv_event;
  if (0 == recycling_list_size_) {
    cv_event = new Event();
    cv_event->InitListElement();
    allocation_counter_++;
  } else {
    cv_event = recycling_list_.PopFront();
    recycling_list_size_--;
  }
  waiting_list_.PushBack(cv_event);
  return cv_event;
}

void ConditionVariable::RecycleEvent(Event* used_event) {
  // We hold internal_lock, courtesy of Wait().
  // If the cv_event timed out, then it is necessary to remove it from
  // waiting_list_.  If it was selected by Broadcast() or Signal(), then it is
  // already gone.
  used_event->Extract();  // Possibly redundant
  recycling_list_.PushBack(used_event);
  recycling_list_size_++;
}

然後 Event class implementation:

// Event provides a doubly-linked-list of events for use exclusively by the
// ConditionVariable class.

// This custom container was crafted because no simple combination of STL
// classes appeared to support the functionality required.  The specific
// unusual requirement for a linked-list-class is support for the Extract()
// method, which can remove an element from a list, potentially for insertion
// into a second list.  Most critically, the Extract() method is idempotent,
// turning the indicated element into an extracted singleton whether it was
// contained in a list or not.  This functionality allows one (or more) of
// threads to do the extraction.  The iterator that identifies this extractable
// element (in this case, a pointer to the list element) can be used after
// arbitrary manipulation of the (possibly) enclosing list container.  In
// general, STL containers do not provide iterators that can be used across
// modifications (insertions/extractions) of the enclosing containers, and
// certainly don't provide iterators that can be used if the identified
// element is *deleted* (removed) from the container.

// It is possible to use multiple redundant containers, such as an STL list,
// and an STL map, to achieve similar container semantics.  This container has
// only O(1) methods, while the corresponding (multiple) STL container approach
// would have more complex O(log(N)) methods (yeah... N isn't that large).
// Multiple containers also makes correctness more difficult to assert, as
// data is redundantly stored and maintained, which is generally evil.

ConditionVariable::Event::Event() : handle_(0) {
  next_ = prev_ = this;  // Self referencing circular.
}

ConditionVariable::Event::~Event() {
  if (0 == handle_) {
    // This is the list holder
    while (!IsEmpty()) {
      Event* cv_event = PopFront();
      delete cv_event;
    }
  }
  if (0 != handle_) {
    CloseHandle(handle_);
  }
}

// Change a container instance permanently into an element of a list.
void ConditionVariable::Event::InitListElement() {
  handle_ = CreateEvent(NULL, false, false, NULL);
}

// Methods for use on lists.
bool ConditionVariable::Event::IsEmpty() const {
  return IsSingleton();
}

void ConditionVariable::Event::PushBack(Event* other) {
  // Prepare other for insertion.
  other->prev_ = prev_;
  other->next_ = this;
  // Cut into list.
  prev_->next_ = other;
  prev_ = other;
}

ConditionVariable::Event* ConditionVariable::Event::PopFront() {
  return next_->Extract();
}

ConditionVariable::Event* ConditionVariable::Event::PopBack() {
  return prev_->Extract();
}

// Methods for use on list elements.
// Accessor method.
HANDLE ConditionVariable::Event::handle() const {
  return handle_;
}

// Pull an element from a list (if it's in one).
ConditionVariable::Event* ConditionVariable::Event::Extract() {
  if (!IsSingleton()) {
    // Stitch neighbors together.
    next_->prev_ = prev_;
    prev_->next_ = next_;
    // Make extractee into a singleton.
    prev_ = next_ = this;
  }
  return this;
}

// Method for use on a list element or on a list.
bool ConditionVariable::Event::IsSingleton() const {
  return next_ == this;
}

謝謝收看。

經驗幸福

現在的我，正按照我的意識去做事。殘忍的是，只有鬼才知道你是多麼重要！為什麼我那麼窮？

其實，沒有錢對我並沒有妨礙，沒有錢也不會痛苦的主因，幸福不是取決於一個人口袋有多深，而是「某個深層原因」。

「某個深層原因」是什麼？數學？每個人有自己的原因，對我來說，數學算是一個原因。為什麼我這麼說？因為我經驗了數學。

事實上，數學雖然打開通往知識的大門，但真正提供頓悟的內容，卻少得可憐。例如，我曾經頓悟「極限的定義」。那怎麼頓悟的呢？在數學的世界裡，數學的真實被所謂條理清晰的各種定義、定理完全掩蓋。經驗的本質被剝奪殆盡，取而代之的只是一些定理名稱，這些定理又取代了現實。經驗並不住在定理，而是棲身於習題和計算中。

為什麼大家害怕數學，因為得不到感動。我做數學就是要有感動，感情發達，就能暫時擺脫理智的控制，數學裡最好的經驗，都是從錯誤計算，無意義計算碰撞得來的，這些默默無聞、避之唯恐不及的錯誤與無意義，才會讓你真正幸福。很多人不懂，這邊解釋給大家聽。如果還是討厭數學，那就找個東西好好經驗，去感受其中的幸福。經驗失敗，正就是幸福所在。

總之，經驗「死的經驗」才會幸福。戒掉「象徵的生活」，這是我必須要做的。

打房

最近政府不斷「打房」，房價依然居高不下，這是為什麼呢？

我們先來釐清幾件事：誰才是房地產市場最大的玩家？三黃一劉？傻瓜，最大的玩家當然是央行，是政府。玩的過彭老的請舉個手？對於市場最大玩家，大家還是尊重一下大咖吧。

房地產市場的特色是什麼？房地產循環速度很慢，一個政策就要逆轉趨勢？想太多。但僅管循環速度很慢，但循環規模卻很龐大，一旦向下，死傷會非常慘重。當然，彭老說過：台灣資產不會泡沫化，那我們就要仔細想想，房地產是不是資產？任何人都可以蓋的房子，真的是保值資產？土地才是真正的保值資產。

當房地產交易開始呆滯，寬鬆信用政策突然緊縮，那就要特別小心，高點要到嘍，加上房地產不如股票那麼容易脫手，那種斷頭的痛快感，可是真的很痛滴。

房地產只會自爆，就算你是最大玩家，頂多只能製造幾個 correction waves.

Critical section

In concurrent programming a critical section is a piece of code that accesses a shared resource (data structure or device) that must not be concurrently accessed by more than one thread of execution.

參考 Log of /trunk/src/base/lock.h

lock (= critical section) 主要架構如下，注意 LockImpl 的技法 (opaque pointer)，很多 OS dependency 的 utility class 可以採用這樣的技法，事實上，Qt framework 狂用這招。

class Lock {
 public:
  Lock() : lock_() {}
  ~Lock() {}
  void Acquire() { lock_.Lock(); }
  void Release() { lock_.Unlock(); }

  bool Try() { return lock_.Try(); }
 private:
  LockImpl lock_;  // Platform specific underlying lock implementation.
};

在 Win 平台上，

::InitializeCriticalSectionAndSpinCount()

API 是最大的亮點，可以參考裡面寫的 comments. Standard posix 十分正常，看過就好。

看屋心情第二篇

早上爬七星山。

下午轉戰和瑞建設的托斯卡尼翡冷翠，坡面唯一的好處就是地球暖化海平面上升淹不到你。個人討厭坡面，除非是天母坡面或是陽明山坡面，這是缺點一。缺點二機能不太好。缺點三外面的路大車太多，又開很快，超不優。缺點四價格太硬，原先售價個人猜測600，結果上個斡旋出660不賣，靠杯，很撐喔。

此外，入住率超低，感覺很詭異，如果是好房子，就應該住滿滿。不過這又產生一個矛盾，假設住滿滿，表示超過三百戶跟我一樣窮的窮人被洗進這個社區，這種居住品質，真的只能顆顆了。

PS.沒有部位也是一種部位。還是先讓市場自由表態吧！

看屋心情

有些人看多，有些人看空。我看到價格和心理。因為我對此物件無緣，就算現在是循環低點，我仍會空手而回。

此物件位於舊新莊，早期舊新莊的發展，台灣史都有說就不多講了。最近炒的很熱的新莊副都心，有別於老新莊，是全新發展的新市鎮，被台北市洗出去的年輕人（包括我），負擔不起的年輕人，可以考慮這塊有潛力的地區。

明天轉戰紅樹林的房子。以投資觀點來想，真的不想丟。不過，要考慮父母親的觀點，幹，伸頭一刀，縮頭也是一刀。

Re: 暴力傾向

首先，沒有「正常人」這回事，一旦進入吵雜的境界（非常生氣），稍微失常的人，可能不知不覺中，自然就會產生某些後果（摔東西、暴力），讓人退化成小學生，反應切換成全自動，無法冷靜思考，推理能力大減。

很遺憾，這些後果沒有一個好的！！！

對女人摔東西沒什麼，但他__的實在很容易跟家暴混淆。

Re: 男生被甩該怎麼調適心情?

我也有類似的經驗，交往第五年開始工作，工作自然就會累想休息，女友就開始覺得我沒陪她，然後就沒感覺，死氣沉沉，她也跟她媽媽講，所以我就順勢提分手。

老實說，分手當下發生什麼原因，我也不知道，想了幾個月，大概是工作後太累沒空陪女友。有些原因自己要去找答案，這不簡單。找不到答案，時間會沖淡一切，慢慢就會回復平靜，八個月後我就好啦。當下的感覺一定很難受，自己也不喜歡講感情事，更談不上怎麼面對。

所以我乾脆不面對，線上麻將一直輸，改打大老二，大老二再輸，十三支總會贏吧，所以開始找新的興趣，當然你還是會想她，不可能不想的啦，敗了iPhone，聽到情歌很難過，然後死命的聽，好像梁靜茹知道你的心情，買了D90，來到曾經來過的風景區，還是會難過，砸10-20進股市，又回憶起她對股市冷淡的反應，可愛極了，就算回南部老家，看到那張雙人床還是會哭泣，又不是死魚，人就是會有情緒，有感情，啥洨放下呀，不要難過呀，都是豪洨的 = =a

什麼過的比她好，比她還要幸福，怎樣怎樣，種種不甘心，都是多的，當然，千萬不要傻事，沒有人會同情你 = =a

能做的就是讓時間沖淡一切，想一下原因，想一下哪裡做的不好，想一下你能付出什麼，想一下你下一步要找怎樣的女孩。或許心理學的書可以指引你方向，那就買來看看，可能在書店會碰到不錯的妹，或許一瓶700ml三節高梁可以讓你放鬆，那就乾了吧 (誤)你的答案，得要自己才能回答。我的做法是找新的興趣。

反正人生就是這樣，難過是正常的啦，你應該高興你還有兩億...

回憶跟記憶，這是你人生的一部份，好好珍惜吧 XDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

回應：社會觀感

萬變不離其宗，一個字，錢。簡單說，社會觀感就是社會大眾的看法，看你買不買單而已。男人花錢買房子，建商開心，男人開心，女人開心。男人花錢買車子，車商開心，男人開心，女人開心。女人花錢出國，旅行社開心，男人開心，女人開心。

父母親很聰明，一下就看穿這個金錢遊戲，勸我不要買四輪，房子除非一次買斷，不然不要買。房子買不起，車子開不起，那就克制自己的慾望，轉移自己的注意力，父母親從小就不限制零用錢，零錢放在門口的盤子，沒有任何紙鈔，我跟我妹要多少自己拿，金錢使用完全透明。

上一代有上一代的包袱，當大家這樣玩，而你不這樣玩，就得面臨一些壓力，很多鄰居告訴我媽，這樣給零用錢，小朋友會亂花，我媽不為所動，自己的小孩還要你來教？很多鄰居一直炫耀小孩有車有房，爸媽仍然不為所動，因為他們知道，二十年房貸是很沉重的壓力，在台北市根本不需要汽車。爸媽也很討厭一堆繁文縟節，跟我說結婚就開個兩三桌，辦在家裡就好了，未來女友聽到應該會爆炸吧 XD 他們也交代我說以後要做大體老師，不要搞傳統那一套。總之，父母親為我跟我妹擋下太多東西，很感動，很偉大，父母親真的是我一生競爭的對手。

不要管別人的事，不要羨慕別人，做自己，為了夢想 (出國/事業成就/讓父母過好日子/...) 勇敢去追，幫助社會，盡量樂觀一點，看開一點，這樣就夠了。

回應：會不會羨慕那種天生家裡很有錢的人

手癢回一下。鼓勵(?)像我一樣受苦受難的窮人。

沒錯，我是人，我會羨慕。因為知道自己是多麼的無能，所以會羨慕，夢想未來一定會成功。可是，現實是殘酷的，許多因素是天生的，怨不了別人，既然怨不了別人，那就對自己好一點，長遠來看，我們都死了，難道臨死之前，不能看開一點嗎？

這世界有太多陷阱，有太多看不見的玻璃，舉例來說，台灣升學管道似乎很公平，但許多研究指出，會不會念書，父母DNA早就決定好了。

再舉個例來看，交男女朋友，看似自由市場你情我願，實際上跟生活背景有關，與其說「選擇」男女朋友，不如說「生活背景」選擇了男女朋友，如果我只是個 B咖女藝人，卻肖想吃汪小菲，我還不如吃屎算了，我的生活、我所接觸的，根本沒辦法跟大S 比。千萬不要看不起大S，至少她出過幾張CD，寫過幾本書，演過幾部戲劇，這些成績足以打敗全台灣 99% 的女性。

蘇老大說的好：且夫天地之間，物各有主，苟非吾之所有，雖一毫而莫取。惟江上之清風，與山間之明月，耳得之而為聲，目遇之而成色。取之無禁，用之不竭。

羨慕別人沒錯，出身卑微也沒錯，努力完成夢想也沒錯，但「太貪」是天殺的錯，貪心真的會害死人。如果買不起帝寶，可以去東北角海岸走走，吹吹風曬曬太陽，有錢人再怎麼有錢，也不可能買下整片太平洋，吃大餐跑夜店不一定真的爽，窮人娛樂也能很有趣。

回頭看看自己，雖然窮酸，但卻相當自豪，自豪能夠看的很開。在能力範圍完成自己的夢想，玩不起的就不要玩。

我相信你一定會成功。

交易哲學

(1) 目前資金算了不要寫，但每天都要看。

(2) 每天看未實現損益，損失/獲利就是成績，天天看自己的成績，才會逼迫自己不斷思考。何不警告自己?

(3) 最短捷徑法則。

(4) 用錢看事情不會錯。盧彥勳。職業賽，真的沒有那麼簡單。

(5) 凡是可疑的事物，我們都應當把它們看作是虛妄的。(決策是一種判斷，是各種替代方案之間的選擇，決策很少是「對」與「錯」之間的選擇，頂多是在「大致正確」和「可能正確」之間選擇，但很多時候，決策其實是在兩種方案之間做選擇，而且無法事先証明哪個方案更適當。尋找更多的可能。除非聽到反對意見，否則不要輕易決定。沒有退路的決策，等於孤注一擲。)

(6) 為了追求真理，我們必須在一生中，儘可能把所有事物都懷疑一遍。

百年泡沫絕不會發生

疑問：央行大舉買匯阻升新台幣並壓低匯價，強力干預匯市一方面造成外匯存底迅速膨脹。

現象：央行外匯存底的幣別組合早就進行調節，央行外匯存底持有的外幣，不能是單一國際貨幣，未來應是美元、人民幣及歐元三大主要貨幣「三強鼎立」。因人民幣不是國際化貨幣，且資本帳未開放，目前央行沒有投資人民幣。

現象：新台幣要像柳樹一樣有彈性，颱風來才不會折斷。

現象：(周)目前央行掌握到的情況，出口廠商報價都在三十元以上，若新台幣升值，中小企業的競爭力會遭遇困難。

看法：這是一場很艱難的戰爭。(這等於沒說)