((Assets - liabilities - intangible assets) / common shares outstanding)

Book Value per Share

((Assets - liabilities) / common shares outstanding)

An algorithm that trades stocks with the highest book value per share values weekly.

import quantopian.algorithm as algo
from quantopian.pipeline import Pipeline
from quantopian.pipeline.filters import Q3000US
from quantopian.pipeline.data.morningstar import Fundamentals as ms
import quantopian.optimize as opt

import numpy as np
import pandas as pd


def initialize(context):
    context.FINE_FILTER = 5
    context.stock_weights = pd.Series()
    algo.attach_pipeline(make_pipeline(context), 'pipeline')

    schedule_function(
        stocks_weights,
        date_rules.week_start(),
        time_rules.market_open()
    )

    schedule_function(
        trade,
        date_rules.week_start(),
        time_rules.market_open()
    )


def make_pipeline(context):
    univ = Q3000US()
    factor = ms.book_value_per_share.latest.rank(mask=univ, ascending=False)
    top = factor.top(context.FINE_FILTER)
    pipe = Pipeline(
        columns={'top': top}, screen=univ)
    return pipe


def stocks_weights(context, data):
    df = algo.pipeline_output('pipeline')
    rule = 'top'
    stocks_to_hold = df.query(rule).index
    stock_weight = 1.0 / context.FINE_FILTER
    context.stocks_weights = pd.Series(index=stocks_to_hold, data=stock_weight)


def trade(context, data):
    target_weights = opt.TargetWeights(context.stocks_weights)

    constraints = []
    constraints.append(opt.MaxGrossExposure(1.0))

    order_optimal_portfolio(
        objective=target_weights,
        constraints=constraints
    )

Book Value Yield

((Assets - liabilities) / close price)

An algorithm that trades stocks with the highest book value yield values weekly.

factor = ms.book_value_yield.latest.rank(mask=univ, ascending=False)

Cash Return

((Cash flow operations - capital expenditures) / enterprise value)

An algorithm that trades stocks with the highest cash return values weekly.

factor = ms.cash_return.latest.rank(mask=univ, ascending=False)

Earning Yield

((Diluted earnings / common shares outstanding) / close price)

An algorithm that trades stocks with the highest earning yield values weekly.

factor = ms.earning_yield.latest.rank(mask=univ, ascending=False)

Enterprise Value to EBITDA

((Common equity + preferred equity + minority equity + total debt - cash and cash equivalents) / net income - (interest + tax + deprecation + amortization))

An algorithm that trades stocks with the highest enterprise value to EBITDA values weekly.

factor = ms.ev_to_ebitda.latest.rank(mask=univ, ascending=False)

Free Cash Flow Yield

((Cash flow operations - capital expenditures / common shares outstanding) / close price)

An algorithm that trades stocks with the highest free cash flow yield values weekly.

factor = ms.fcf_yield.latest.rank(mask=univ, ascending=False)

Price to Book Ratio

(Close price / (assets - liabilities))

An algorithm that trades stocks with the highest price to book ratio values weekly.

factor = ms.pb_ratio.latest.rank(mask=univ, ascending=False)

Price to Earnings Ratio

(Close price / (net income / common shares outstanding))

An algorithm that trades stocks with the highest price to earnings ratio values weekly.

factor = ms.pe_ratio.latest.rank(mask=univ, ascending=False)

Price to Sales Ratio

(Close price / (revenue / common shares outstanding))

An algorithm that trades stocks with the highest price to sales ratio values weekly.

factor = ms.ps_ratio.latest.rank(mask=univ, ascending=False)

Sales Yield

((Revenue / common shares outstanding) / close price)

An algorithm that trades stocks with the highest sales yield values weekly.

factor = ms.sales_yield.latest.rank(mask=univ, ascending=False)

Sustainable Growth Rate

(Net income / total common equity * (1 - dividend per share / diluted earnings per share))

An algorithm that trades stocks with the highest sustainable growth rate percentages weekly.

factor = ms.sustainable_growth_rate.latest.rank(mask=univ, ascending=False)