text:
# Notes on Zettelkasten, GTD and the Memex

(Recently I started hearing about this note taking system called Zettelkasten. (Seems, as usual, I’m a bit late to the game as the Interwebs was talking about it more in 2020 and prior…) What follows is some notes and thoughts about it and how it connects with other thoughts.)

## Zettelkasten

Zettelkasten (or ‘Slip Box’ / ‘Card Box’ in English) is a note taking system used (and perhaps invented) by Niklas Luhmann. He said it was the way he was able to so prolific in publishing academic papers. It involves writing notes/thoughts on small cards and organizing them in a tree structure, physically in a card box. Each card gets an index number (based upon where it is the tree) and references to other cards if applicable. Index numbers were made of letters and numbers alternating thus allowing for the branching. Cards “1” and “2” are not particularly related, but “1a1” is a note that continues from “1a”, while “1b” is a note continuing from “1” but not necessarily related to “1a”. What Luhmann thought was very important was that there was not any organization a priori. He felt that “accident” was very important and having an organization ahead of time would limit the possible thoughts one could have.

More details on this system and how to use it can be found in Luhmann’s paper and also in Sönke’s How to Take Smart Notes.

## GTD

How does this connect with GTD? Luhmann’s process of reading and taking notes reminds me a little of the GTD’s separation of capture and processing.

Luhmann’s system had three types of notes: “fleeting”, “literature” and “permanent”. The only differences as far as I can really see between “fleeting” and “literature” notes is where they came from and how much supporting bibliographic material they may have. Both are written down at any time and collected together. Later (but not too much later) they are reviewed and either discarded or turned into permanent notes. Permanent notes are stored in the Zettelkasten. As notes from the inbox are processed one decides what one needs to do with them, where do they fit into the system.

## Memex

In 1945 Vannevar Bush published an article in The Atlantic Monthly entitled “As We May Think”. In it he describes the “Memex” a sort of work desk / computer which could be used to search for and view documents (on microfilm) stored in the device. More data could be added to it - either personal notes / documents which would be scanned in; annotations on the documents; or even new documents bought or given to the user by others (you could make copies of documents to share with others…)

Basically if you squint at it just right he described a sort of World Wide Web. Documents available at your fingertips and documents were linked together. This availability and linking would allow people to do research on any topic quite easily, synthesizing existing information into new information.

One thing he mentioned that the Memex would have tat we do not have in the WWW is his idea of “trails”. With the Memex you would be able to annotate and save the “trail” of our research, that is you could save the fact that looking at document A led you to document B which lead you to a footnote of document E etc. etc.. These trails were another piece of data one could store and share with the Memex. A trail could be shared with a colleague thus not only sharing the documents you looked at, but how you looked at them.

I think it could be interesting if this idea of trails could be developed.

## Synthesis

So how do these thoughts connect? For me the idea of the Zettelkasten and of the Memex are similar, how to store and access information; how to synthesize information into new information. That alone is a good thing - but how to deal with all the information you may be putting into the system? Via GTD’s separation of capture & process, Zettelkasten’s fleeting vs. permanent notes.

A new piece of information or thought can be captured quickly - now your brain can go back to the job at hand. Later (hopefully not too much later) one goes through all that captured information and decides what to do with it. Some of it may, in retrospect be not important - you discard. Some may be important - you store it. Not only that but during storage one synthesizes it with existing knowledge which may immediately create new information.

# REPL Driven Development

(As I was preparing to write this blog I see that 1) a few other people seem to be discussing around this topic (e.g. David Vujic), Erik Engheim, et al.) and 2) that I already discussed this some 10 years ago TDD and REPL Analogies?! Just adding this note to make it clear that this is nothing new, just my thoughts and experiences.)

## Background

I am the author/maintainer of an Exericism track for Common Lisp. Currently we are doing a big push to prepare and release v3 of the platform. During this push I’ve been doing more Common Lisp coding than usual1 which has brought me back to REPL driven development.

I personally find it very useful to be able to “play around” or explore a problem before sitting down to actual produce a software solution. Sometimes the code, as I explore and play, becomes the “real” code I will keep. Thus this is not a prototype or spike where the output would be thrown away, or at least not shipped to production2.

At the time of my earlier writing I was working in a language which did not have a strong REPL offering (or any at all) and found TDD to be a way for me to do this exploration in a reasonable fashion. I found, lacking a REPL, TDD provided me a fast feedback cycle which was necessary for my exploratory approach. Having a REPL shortens that feedback cycle for exploration.

## What is REPL Driven development

A REPL with full editing features (such as SLIME or SLY in GNU Emacs) combines the power of the language, the power of the editor/IDE, with fast feedback that allows me to explore and play with ideas.

Like TDD, REPL Driven Development/Design lets me experiment with different interface designs of how my modules3 will fit together. It also allows me to quickly check that my most recent changes haven’ t caused any problem.

I can also use it when I’m unclear on what the solution might even be. For example when consuming a JSON formatted configuration file for my exercism track, and I want to better understand how the different parts of the data related to each other, where there may be inconsistencies or lacunae in the data.

The general workflow is to work with some code in the REPL, testing and designing it and when it seems ‘right’, saving it to a source file. The workflow can also include working in source files and evaluating parts of the code to load them into the REPL. In a well integrated REPL there is little difference in the editing experience between the REPL and a source file.

In Common Lisp the REPL includes a debugger with a sophisticated condition and restart system which lets me write code I wish I had, then when I run it I am asked what to do about the undefined functions or variables. I can choose to quickly define them or stub them out and then continue, or I can quit the debugger to start the feedback loop again after making further changes.

## What it is not

One thing that this cycle does not provide is a a set of tests which can be run repeatedly as you get with TDD. However the interactions at the REPL involve many of the same test cases you’d use in TDD - typical data, empty data, aberrant data, etc. So those can be collected, mixed with some assertions and used as the tests to save for later regression testing / documentation.

## Next steps

To be honest, adding bindings when stopped in the debugger is not part of my workflow because it is still not ‘natural’ for me to do, my fingers all too quickly dismiss the debugger from lots of habit. This workflow is my next experiment.

1. I am a hobbyist programmer of the language at best…

2. That never happens.

3. By module I mean any ‘building block’ of the software I am building. These might be functions, classes, packages, modules, sub-modules, all of the above. (cf. Parnas).

# How to Write a Heroku Buildpack for Fun and / or Profit

Heroku buildpacks are used to prepare (/e.g./ build/compile) an application to allow it to be run by Heroku on their dynos. There are many that exist so it is not likely that you will need to write your own. And that is quite true for the one I wrote. But I wrote one partly to find out how to do it, so let me share what I learned.

The API for Buildpacks is pretty simple and it can be easy to write one. The API is three scripts that will be run by Heroku when it runs the buildpack: detect, compile, release. Buildpacks are git repositories so it is common to host them on GitHub (but that is not required).

While I say that the API is simple, I hope it is useful to summarize details of the API here. Perhaps restating it with my own words will help others (or just me in the future).

## Environment that the buildpack is run in

Buildpacks are run on the same stack as the application is.

Buildpacks are run in their own directory. This is not the directory where the application code is. Also this buildpack directory is not available to later buildpacks nor the application. So if the buildpack creates build artifacts those must be put somewhere else.

Besides the buildpack directory there are three other directories available to the buildpack:

• BUILD_DIR: this is the directory where the application code is.
• CACHE_DIR: this is a directory which can be used to cache build artifacts (see below).
• ENV_DIR: this is a directory which contains information about the [Heroku Config Vars][heroku-confi-vars] (see blow).

## bin/detect

This script’s job is to decide if this buildpack should be run. It is passed a single argument, the BUILD_DIR. This script typically will work by checking for a particular file in BUILD_DIR. If the buildpack should not run the script should return a non-zero value. If the buildpack should run then besides a zero return value it must also print to standard output a “human readable” name. This will show up in the build logs and shows that the buildpack is chosen.

## bin/compile

This script is a huge part of a build pack. It has the job of compiling/preparing the application. It is passed three arguments: BUILD_DIR, CACHE_DIR and ENV_DIR.

There are two environment variables available to the compile script:

• STACK: which stack the buildpack is running on
• SOURCE_VERSION: the “version”. For applications deployed via git pushes that will be a commit SHA.

Heroku Config Vars are not available as environment variables to the buildpack. But they are available via the ENV_DIR (see below).

Any output to standard output will appear in the build log. It is recommended that buildpacks output messages in ways that fit the style of the other parts of the build logs (see below for some shell script functions to help with this).

If a buildpack needs to communicate environment to next buildpack it can write a script export in the buildpack’s directory which will be executed before the next buildpack is run.

If a buildpack needs to communicate environment to the application (e.g. PATH) it can write shell scripts to BUILD_DIR/.profile.d. These will be run during dyno startup. They will be run after the Heroku Config Vars are set in the environment. Each script should be named with a .sh suffix. There is no guarantee to the ordering which these files will be executed.

## bin/release

The release script is run after compilation and returns meta data back to the build process. It is passed a single argument, the BUILD_DIR.

It must return, on standard output, a YAML formatted hash with upt to two keys: addons and default_process_types.

Any addons specified will be added to the application the first time it is deployed. The default_process_types key defines default Procfile entries to use.

A good start is with the following script which creates an empty YAML hash. It can be expanded with the required keys when needed:

#!/bin/sh

cat << EOF
---
EOF

## CACHE_DIR

The CACHE_DIR is a directory that can be used to store build artifacts between builds. For example if a buildpack downloads and installs some software, it can store that in CACHE_DIR and then skip the download and install the next time.

Note, the API specifies that the CACHE_DIR may not exist, so if bin/compile wants to use it it should ensure it exists before doing so.

## ENV_DIR

This directory contains files for each Heroku config var. For a config var FOO=bar there will be a file FOO with the contents bar.

## bin/compile logging helpers

Since the compile script should use output format that is similar to the rest of the build process the following shell functions may be useful

log_header() {
echo "-----> " $* } indent() { sed -u 's/^/ /' } log() { echo$* | indent
}

They can be used like this:

log_header "Staring Build..."

cat output.txt | indent

log "Build complete."

which will produce:

-----> Starting Build...
...contents of output.txt...
Build complete.

# Standard Joke

Arabic-to-Roman number conversion is a common programming exercise, often used as a TDD exercise. It is an exercise on many Exercism.IO1 language tracks including my own track for Common Lisp2.

So how do you solve this in some arbitrary programming language?

Typically people write some code to loop through a mapping of numeric values to roman numeral digits and do repeated decrements while accumulating the roman numeral digits. That is to say if you start with 1970 and your mapping contains 1000 => "M"; 900 => "CM"; 500 = "D" you decrement by 1000 and accumulate "M", then since the resulting number is under 1000 you try the next mapping, decrement by 900 and accumulate "CM" etc.

How do you do this in Common Lisp?

(format t "~@r" 1970)

Yes: Built. In. To. The. Language.3 (In fact using ~@:r will provide output as using the alternate roman numeral format which does not have special cases for numbers like 4. i.e. it will output “IIII” rather than “IV”.)

Common Lisp4 is a language with an ANSI specification5. The specification process went from the early-to-mid 1980’s to the mid-1990s. Its goal was to create a single “common” Lisp collecting the good bits from all the splintered Lisp languages used at the time. I’ve heard that it involved a good amount of “horse-trading” as each interested party tried to get the resulting language to contain their special or idiosyncratic feature. So how did it come to have this odd feature?

With a little digging I have found the real story: It was a joke.

In “The Evolution of Lisp”6 Richard Gabriel explains that in 1974 Guy Steele Jr put roman numeral handling into MacLisp7 as a hack. BASE and IBASE were variables which specified the output and input bases for numbers. Before his hack they were limited to vales between 2 and 36. Steele added the ability for them to be set to ROMAN. Thus if set code like (+ i 1) would evaluate to ii since the expression would have been read in as the equivalent of (+ 1 1) and upon output the value 2 would be represented in roman numerals. (It seems in the original announcement of this ‘feature’ that you could also set BASE and IBASE to CUNEIFORM which would cause your Lisp to become wedged. Oh so witty.)

From that time this feature became a bit of a traditional hack - being ported to ZetaLisp8 as part of FORMAT.

Thus when Common Lisp was being created this feature was included in FORMAT9 as it was a normal feature of that function in the Lisps that Common Lisp was being aggregated from.

Since then this feature also found its way into Clojure10 as part of its cl-format11 function.

# Writing Mix Tasks for Fun and Profit.

I’m beginning to learn a little Elixir & Phoenix and I ran into a case where I wish I had a Mix task for something. Specifically I wanted to run npm scripts with mix so I’d only have one command to run instead of both mix and npm for my toy Phoenix project.

Writing a Mix task is reasonably straightforward with only a few steps:

1. If you want to create a mix task called “echo” then create a module called Mix.Tasks.Echo. The task name seen in mix help is based upon the name of the module minus Mix.Tasks. (The module needs to be called Mix.Tasks.Something otherwise mix will not see it.)
2. Add use Mix.Task to this module.
3. Write a public method called run. It has the type signature: run([binary]) :: any. That means that it will get a list of strings (the command line arguments) and can return anything.
4. Add a @shortdoc. This will be used as the text in mix help. Without this your task will not appear in mix help but will still be usable.
5. Optionally add a @moduledoc. This will be used if you run mix help YOURTASK

You can put this module where ever you want in lib but typically you would put it into lib/mix/tasks.

That’s it.

An interesting thing I found was that step #2 was not actually needed. That behaviour defines @shortdoc so without it you cannot use @shortdoc to add the task to mix help output.

Since I was creating a mix task for use in a build I needed to make sure that if the task was not successful that mix would return an error code so that the shell could see the error and fail a build. At first I assumed that the return value of the task was how that would be done; however I didn’t find much documentation about this. I experimented with some likely return values like :error or {:error, "something"} but that had no effect, it always returned a zero exit status to the shell. Ultimately I choose to raise an error when the task didn’t work and that definitely caused a non-zero exit status.

If you want to see the end of result of this experimentation you can check out my first ever hex package: mix-npm. The source can be found in the GitHub repository: verdammelt/mix_npm.

# Learning From My Apprentice

My company, Cyrus Innovation, has started an Apprenticeship program. This program involves bringing on people who are brand new to programming and pair them with a Senior developer to train them in good practices. About a month ago I ‘acquired’ an Apprentice: Paige.

I’ve never done this sort of thing before and I quickly came to realize that the relationship wasn’t just Master & Apprentice but really Apprentice-Master & Apprentice. I am not only learning as I go what it means to have an Apprentice but also learning from my Apprentice.

Even more than normally during pair-programming I feel I need to explain myself. Not only explaining how to do something in the programming language, but how to do it with our tools, and how we’ll do something in the context of our team. Add to that explaining the why of it all as well. This exercise helps me remember and reconsider why I do things the way I do, why they are important.

This also brings to light good practices which I have chosen not to do in this current situation. Perhaps there are reasons, perhaps those reasons are good, sometimes they are not. By having to explain the trade-offs and reconsider the bad reasons I am learning why I make these decisions.

Also by embodying some good behaviors she is teaching me some tricks about how to learn. She is a careful attentive listener, always asking questions to get clarification. She also tests her knowledge by sharing what she does know (even if not sure) which either adds to the collective knowledge or is corrected.

So I hope she is learning something by pair-programming with me; but I know I’m learning something from her.

# Quickie: Less Columns on Your Board

So you have a “Agile Board”(TM) congratulations! If you are like any of the people I’ve worked with recently you’ve got lots of columns to keep track of all the possible states a story card could be in.

Back away from the board…

You should start with very few columns. I think four should be plenty:

• Backlog
• Current
• Doing
• Done

Backlog is the place to keep all your new ideas. Make sure the next priorities are at the top and ready to go, as you go down the list don’t worry about the rest too much, they can stay vague.

Current is for the things you are planning on doing this iteration. Use the Goldilocks principle. Don’t agree to do too much or too little. Just the Right(TM) amount.

Doing is for things that are being worked on RIGHT NOW. A good number of items here is a function of the number of people on your team and how they collaborate (pairing, mobbing, solo if you must). If there are too few or too many items there is a problem - discuss it. If something stays here for days that is the sign of a problem - discuss it.

Done is for keeping track of the valuable things you are delivering as a team. Rejoice. Throw them away after sufficient rejoicing (sometime after the next iteration starts is a good time).

What about Ready for QA? or Ready for Deploy? you ask. I’d ask why isn’t QA and/or Deploy part of your definition of done?

What about Blocked. OK this one might be useful. But a red sticky (or equivalent for non-physical boards) on the card is probably enough. Moving it to another column makes it less visible, and a card being blocked is a problem and we want problems to be visible.

Of course it is your process not mine. Use the columns you need. But know why you need them, and feel free to add and remove them if after discussion you realize the board is not serving you anymore.

# The Craftsperson and Their Tools

When I think of how “Craftspeople” do their work I think of tools. Good tools. They pick good tools because they know that it is easier to get the job done when you have the right tool, and it is well made. They don’t use a tool that is the wrong size for them, the tool fits their hand. They may also modify their tools to better fit their hand.

Sometimes a craftsperson will make entirely new tools for their work. It might be a special jig for cutting the same type of cut in a lot of lumber, or for drilling the same sort of hole. Sometimes these special jigs even come into common use, such as a door lock installation jig, or a mitre box.

Because a craftsperson uses their own tools, and special tools, they might seem to have a handicap when they don’t have those tools. But a unless the job cannot be done except with a particular tool (it is very difficult to cut a piece of wood with a hammer), they can still get the job done (albeit perhaps a bit slower).

This is because they know how to do the job; the tools are just how they go about it.

Some people think that the idiom: “A poor craftsman blames his tools.” implies that tools are not important. This does not mean that tools are not important! This means that a craftsperson knows that the failure to do a good job is not the fault of the tool; but the fault of the craftsperson: their skill, or their choice of tool.

Do you pick the right tool for the job? Do you change it to fit your hand? Do you make special tools for the work?

# Gotcha of Using YouTubePlayerFragment and ViewPager for Android

(Cross posted to the Cyrus Innovation Blog)

Recently I learned some Android programming by writing a simple app for a client. It was a great opportunity to learn the platform and how “easy” it is to write an app. I ran into one ‘gotcha’ that I thought might be valuable to others.

One feature that was needed was a swipeable carousel of YouTube videos. Google provides some widgets for showing YouTube videos on an Android device and YouTubePlayerFragment was a (almost) perfect fit for my needs1. Also ViewPager was just the thing for creating the swipeable list of items. It was easy enough to create a subclass of FragmentPageAdapter which knew the list of videos and created YouTubePlayerFragments as needed (actually a subclass whose job was to handle the initialization of the YouTubePlayerFragment).

While this was easy to code - it was not so easy to make it actually work.

Trying to play videos resulted in a cryptic message about the player not playing because it was not visible on the screen. The coordinates in the error message made it seem like the object was way to the left of the visible screen. That was the first clue. It was perplexing though since the player was quite obviously right there on the screen.

Some debugging gave me the second clue I needed. When I pressed play on the player on the screen, multiple players were firing events saying that they were playing. Multiple players?

Reading2 into the documentation of ViewPager some more told me that it will request multiple views from the ViewPageAdapter, so that other views are “ready to go”. But why did they all respond when I clicked on one of them?

More debugging did not solve the mystery but solidified my hypothesis: The YouTubePlayer and/or YouTubePlayerFragment has state shared between all their instances. That is the only explanation that would fit the observed behavior.

So I needed a way to ensure that only one YouTubePlayer was in play at a time. The ViewPager documentation says you can change the number of other pages that will be created. Changing that did not work for me - at least one other view was always created. That left me with ensuring that only one player was initialized.

I tried various event listeners but found that none of them fit the need. Sometimes I would get an event firing both on the active and the inactive viewer and it was not possible to tell the difference. Finally I found one thing that did seem consistent and usable: setUserVisibleHint. It was called on the fragment with a true value when that fragment was the one shown to the user and was called with false when it was not. So I made sure my fragment was not initialized until it got told that it was visible; and then released it when it was no longer visible.

1. Except for the supremely annoying fact that the YouTube player widgets DO NOT WORK on emulators. So I had to do all this work with a physical device tethered to my machine. Like a savage.

# Initial Emacs Setup for React/ReactNative

(Cross posted to the Cyrus Innovation Blog)

It looks likely that I’ll be doing some ReactNative work soon so I took some time to start setting up my Emacs environment. All my relevant setup can be found in the init-react.el file in my GitHub dotfiles repository. This is likely to change so the previous link may not match the code below. The code below matches specifically the initial version (59e7728).

Hereinbelow I will add more annotation to those already found in that file along with snippets of code.

The first thing that needed to be set up was a mode for React code. React code files can mix Javascript with HTML markup and it does not appear that js-mode (the built-in JavaScript mode) handles that. After a short Googling it looks like web-mode is a mode that can handle it. After some brief testing it does appear to work reasonably. It appears that the React/ReactNative community has not decided to use *.js or *.jsx as the extension for the code files and since web-mode appears to handle JavaScript just fine I chose to use it in all cases.

(add-to-list 'auto-mode-alist '("\\.jsx?\$" . web-mode))

The next thing I wanted to get set up was a linter. I thought this especially important as React uses an ES6 dialect of JavaScript which I am not entirely familiar with yet and a linter can help me “do the right thing”. With a suggestion from a coworker (who has done some React work) I chose ESLint with the AirBnB configuration settings. These defaults prompted me to standardize on two spaces for indentation. (Setting js-indent-level as js-mode is still in use for JSON files.)

  (setq web-mode-markup-indent-offset 2
web-mode-css-indent-offset 2
web-mode-code-indent-offset 2)
(setq js-indent-level 2)

Setting up the linter to run via flycheck took a small amount of work since I don’t like to install project specific tools globally. (I know that this is contrary to current mores, but I have been tripped up by global vs. local installations before so I shy away from them when I can.)

First I needed to integrate NVM with Emacs so that Emacs could run ESLint at all.

(require 'nvm)
(nvm-use (caar (last (nvm--installed-versions))))

(The choice to use the last version found is totally arbitrary. If and when I get more versions of Node.js on my machine I’ll have to make a more careful choice.)

Next I hooked into projectile to look for a locally installed ESLint and use it if found. The projectile-after-switch-project-hook functions are called after Projectile has switched directories to the project so one can simply check the project for the desired file.

(add-hook 'projectile-after-switch-project-hook 'mjs/setup-local-eslint)

(defun mjs/setup-local-eslint ()
"If ESLint found in node_modules directory - use that for flycheck.
Intended for use in PROJECTILE-AFTER-SWITCH-PROJECT-HOOK."
(interactive)
(let ((local-eslint (expand-file-name "./node_modules/.bin/eslint")))
(setq flycheck-javascript-eslint-executable
(and (file-exists-p local-eslint) local-eslint))))

(Note: the function is interactive because I found at least a few times I was looking at a JavaScript file which I had come to not via projectile. By making it interactive lets me use it manually in the rare case I need to.)

Flycheck’s ESLint integration is limited to only certain modes and web-mode is not one of them so I needed to add that to the white-list of modes

  (with-eval-after-load 'flycheck
(push 'web-mode (flycheck-checker-get 'javascript-eslint 'modes))))

With that I can easily write React/ReactNative code with all the bells and whistles I like.

Later I will add support for building and testing I’m sure. But first I need to determine what building & testing in a ReactNative environment will even look like.


text:
Different Amortization Methods for Intangible Assets

Amortization refers to the process of allocating the cost of an intangible asset over the asset’s useful life. Only those intangible assets which are assumed to have finite useful lives are amortized over their useful lives, along the lines by which the benefits are used up. Assets that are therefore assumed to have an indefinite useful life are not amortized.

Intangible assets with finite useful lives include an acquired customer list that is expected to provide benefits to a direct-mail marketing company for three to four years, an acquired patent or copyright with a specific expiration date, an acquired license with a specific expiration date and no right to renew the license, and an acquired trademark for a product which a company plans to phase out over a specific number of years.

Alternative Amortisation Methods

The calculation of amortization for an intangible asset requires knowledge of the original amount at which the intangible asset is recognized, estimates of the length of its useful life, and its residual value at the end of its useful life.

An asset’s useful life is estimated on the basis of the expected use of the asset, considering any factors which may limit the life of the asset, such as legal, regulatory, contractual, competitive, or economic factors.

Similar to what obtains for the depreciation of tangible assets, there are three primary methods of amortization: the straight-line method, the accelerated method, and the units-of-production method.

Under the straight-line method of amortization, amortization expense is calculated as amortization cost divided by the asset’s estimated useful life and is the same for each period. In the accelerated method, the allocation of cost is greater in earlier years, while in the units-of-production method, the allocation of cost corresponds to the actual use of the asset in a particular period.

Question 1

If an intangible asset costs $2,500, has an estimated salvage value of$50, and an estimated useful life of 4 years, what is the amortization expense under the straight-line method?

A. $500.00 B.$625.00

C. $612.50 Solution The correct answer is C. Under the straight-line method, Amortization expense = ($2,500 – $50) / 4 =$612.50.

Question 2

Illicom Pharma acquired a license to produce a new drug for 3 million dollars. Under that license, the company has the right to produce unlimited units of the drug for the next five years. Should the company follow the double declining depreciation method to depreciate the asset, how much should the depreciation expense be in the last year?

A. $600,000 B.$423,050

C. \$388,800

Solution

The double declining depreciation method assumes applying double the depreciation rate applied in straight line depreciation. The straight line depreciation rate should be 1/5 = 20%, which makes the double declining depreciation rate 40% of the asset’s carrying amount at the beginning of the financial period. The table below illustrates how the calculations were made.

$$\begin{array}{|c|c|c|c|} \hline {\textbf{Carrying value at} \\ \textbf{the beginning of} \\ \textbf{the period} } & {\textbf{Depreciation} \\ \textbf{expense rate} } & {\textbf{Depreciation} \\ \textbf{expense value} } & {\textbf{Carrying value at} \\ \textbf{the beginning of} \\ \textbf{the period} }\\\hline {3,000,000} & {40\%} & {1,200,000} & {1,800,000} \\ \hline {1,800,000} & {40\%} & {720,000} & {1,080,000} \\ \hline {1,080,000} & {40\%} & {432,000} & {648,000} \\ \hline {{648,000}} & {40\%} & {259,200} & {388,800} \\ \hline {388,800} & { \text{The remaining value} \\ \text{of the asset}} & {388,800} & {0} \\ \hline \end{array}$$

Describe the different amortisation methods for intangible assets with finite lives and calculate amortisation expense

Financial Reporting and Analysis – Learning Sessions

Share:

format: plain


text:
Further explanation of the Penrose Conjecture

I'm currently a third year maths undergrad, writing a dissertation on the application of minimal surfaces in space.

I have recently come across the Penrose Conjecture that the mass of a spacetime is:

$$m \geq \sqrt{\dfrac{A}{16 \pi}}.$$

What significance does this have in terms of the geometry of a black hole? Also how does this directly relate to that of minimal surfaces? In that, is it purely to do with the apparent horizons corresponding to a minimal surface?

• See arXiv:math/9911173 [math.DG]. Though I have not managed to find time to begin reading the paper, the abstract's second paragraph talks quite a lot about Schwarzschild black holes. – user28355 Feb 2 '14 at 16:25
• Sure, no problem! – user28355 Feb 2 '14 at 16:28
• A Schwarschild black hole of mass $m$ will have an event horizon of radius $2m$ (in units where $\hbar = c = 1$). So the surface area of the black hole is $A = 4 \pi r^2 = 16 \pi m^2$. So any mass $m$ will "gobble up" at least "that much" space. That's the relation to black holes. – Siva Feb 2 '14 at 16:57


text:
## Physics for Scientists and Engineers: A Strategic Approach with Modern Physics (3rd Edition)

We can find the wavelength of the wave as: $\lambda = \frac{v}{f}$ $\lambda = \frac{340~m/s}{120~Hz}$ $\lambda = 2.83~m$ We can find the distance $\Delta x$ between the two points as: $\lambda = \frac{2\pi~\Delta x}{\Delta \phi}$ $\Delta x = \frac{\lambda ~\Delta \phi}{2\pi}$ $\Delta x = \frac{(2.83~m)~(5.5~rad)}{2\pi}$ $\Delta x = 2.5~m$ The distance between these two points is 2.5 meters.


text:
Home

>

English

>

Class 12

>

Physics

>

Chapter

>

Alternating Current

>

When an ac source of emfe=E_(0...

Updated On: 20-06-2022

Get Answer to any question, just click a photo and upload the photo and get the answer completely free,

Text Solution

R= 1kOmega, C=10 muFR=1kOmega, C=1muFR=1kOmega, L=10HR=1Omega L=1H

Solution : c) EmF and AC source E=E_(0)sin(100t)
 We have, omega=100 and phi =pi/4=45^(@)
 tanphi = (omegaL)/R
 rArr I=(100 xx L)/(R)
 If L=10H, then R=kOmega

Step by step solution by experts to help you in doubt clearance & scoring excellent marks in exams.

Transcript

hello everyone when any source of EMF this is connected across a circuit the phase difference between the EMF and the current is observed pi by 4 as shown in the figure the circuit consisting of possibility of CR or RC or series find the relationship between the two element so if you see here the current is lagging voltage is leading so we lead the current voltage lead it means that this is a inductive circuit you can select from the option which one is the inductor which one is the capacitor in case of capacitive current lead here the voltage is dating so c&d can be the option the phase difference is given it it is pi by 4

phase difference tan of phase difference is equals to in case of inductive circuit it will be held is said that the tan theta is 45 degree so I will let tan of 45 degree is equals to omega l bi a physical is omega now if you did it is given in the question so I will write this is equals to omega that is haunted by our is equals to 1 so basically the ratio should be equals to 1 by 100 or you can also see our buyers should be = 210 check from the option so here if you see our is this and unless these in the ratio is 102 this can be option in the ratio is once this can't be select correct option where the RBL ratio is what

what is hundred is present is the option to see will be the correct option


text:
# Assignments

Assignment statements use the <- operator.

a <- b;

Assignment of basic types is by value, and of class types by reference. Assignment can be used in an expression, where it returns the value of the left operand after assignment.

It is possible to declare assignment and conversion operators within a class, allowing assignment to objects from values, or conversion of objects to values, where sensible.

Info

The operator =, often used for assignment in other languages, is reserved for possible future use in Birch (e.g. for declaring equations).


text:
# Can a super computer be built using time dilation?

If I have a very computationally expensive task that no current computer can solve in less than 100 years, I could start the task on a powerful computer, get on board my Super Hyper Extravaganza Space Ship ©™, fly at 0.99999 the speed of light for a while, and when I return to Earth the time dilation effect means that I would have aged much more slowly than my computer. In fact, if I flew long enough, my computer would have aged a few hundred years more than me and the task would be completed.

However there is the issue that everything else on Earth would also have aged a few hundred years more, and the computation that I was solving would no longer be relevant.

If I was to put the computer on the space ship instead that would be silly because, being back on Earth, I would be aging faster than the computer, and from my perspective the task would take thousands of years instead of hundreds.

Is there a way to 'invert' this time dilation? Can I make time pass faster for just the computer, and essentially 'skip forward' to when the task is complete?

• Comments are not for extended discussion; this conversation has been moved to chat.
– L.Dutch
Apr 3 at 4:05
• Scott Aaronson discusses this and other methods to exploit non-Newtonian physics in his Quantum Computing since Democritus lecture: scottaaronson.com/democritus/lec19.html (it also appears in his book, chapter 20) Apr 3 at 10:38

# Yes, But You're Not Going To Like It

Time dilation is all down to frame of reference. So, if you don't want everyone on Earth to age during the computation, you just have to take Earth with you. You already have an unreasonable Super Hyper Extravaganza Space Ship ©™ that can reach and maintain absurd speeds, so...

Make Earth into a spaceship. Will there be technical challenges? You bet. But you will accomplish your desired effect. You will have new, exciting problems, but your initial one will be solved!

• I love this absurdist answer and look forward to your hitchhikers guide style book on the concept 😄 Apr 1 at 8:08
• This is my favorite kind of answer. Apr 1 at 10:20
• Kurzgesagt has an interesting video about that topic youtube.com/watch?v=v3y8AIEX_dU Apr 1 at 12:30
• @jdunlop You would, of course, need to leave the computer behind, as close to the comoving frame as possible, and you would need to come back to pick it up later. Even a K-II civ would find this a challenge...
– J...
Apr 1 at 18:24
• @JohnDvorak - Robert said "take the sun along. So you have all the problems involved with bringing the Earth and a million times the mass (in Fermi numbers). Apr 1 at 19:49

The resolution of the twin paradox rests on the principle that there is an asymmetry between two observers. The observer on the spaceship must, for some amount of time, undergo an acceleration$$^{\dagger}$$ opposing its velocity so that it doesn't simply keep moving away from the observer on the planet. Therefore, the spaceship is, while accelerating, no longer in an inertial frame. If you do the calculations, you find that this leads to the observer in space experiencing time dilation when it returns to the planet. (For more details, see John Rennie's explanation on Physics Stack Exchange.) In short, when it comes to the twin paradox, time flows slower for the observer doing the accelerating.

Therefore, your suggestion would require keeping the computer in an inertial frame while putting the entirety of the universe (or at least Earth and everything else you cared about) in a non-inertial frame, which seems unfeasible with current technology! It's possible that we'll eventually figure that out, but by then, the supercomputer you need (i.e. from the year ~2121, as per your question) will already have been built.

$$^{\dagger}$$ Here, "acceleration" refers to any change in velocity, whether involving an increase in speed or a decrease in speed.

• – nwp
Apr 1 at 9:47
• @nwp It relies on the asymmetry between the two observer because of that acceleration. Apr 1 at 12:03
• @nwp In some cases, no, but does in scenarios that resemble the ones applicable to our situation. All of the situations mentioned there either involve significant departures from Minkowski spacetime or don't allow for the fact that, initially, the computer and everything else are stationary relative to one another (because they're all on the same planet!). Apr 1 at 13:55

### No. There are other ways to get a 100yr algorithm done faster than 100 years.

The physics of this answer have been answered already (no), however theres an engineering answer to how to do 100years of work in less than 100 years.

Firstly algorithms with these kind of runtimes need to be specially designed to be as parallel as possible, fault tolerant and resumable. Every hard drive this algorithm touches for storage is going to fail and need to be replaced over this time period, and when this happens, you need to not lose the progress you've made, or any data you're yet to process.

Apparently this consideration comes up at Google-levels of data, a single pass over all the data in a single database table takes so long, and the number of hard drives and server clusters involved is so large, that statistically one drive will fail per pass over the data. For your algorithm, every hard drive will fail and need replacing. Multiple times.

Because of this already-existing design consideration on your algorithm, and becuase you need to replace hardware anyway (and why buy antique hardware?), you will inadvertently upgrade the hardware over time as new hardware comes out. If computers double in power every 2 years, you can process 2% of your algorithm in 2 years, then upgrade and process 4% in the next 2 years, then 8% the next 2 years, then 16%, then 32%, then the final 38% in the last year. The algorithm will complete after 11 years and 5 hardware upgrade cycles.

Also due to the fault tolerant and resume features of the algorithm, you can upgrade the algorithm over time too, making it faster and more efficient as developers micro optimise every last detail of it over the years, putting out new versions, which the super computer starts using on the next reboot / hardware replacement. Sit a team of developers in a room for a year and theyll be able to speed anything up eventually, making the next year slightly more efficient. They could improve the compiler or 3rd party code to speed up the runtime too. They could discover new maths to totally rewrite the approach. How much this returns depends on how optimised the algorithm already was, I'd be surprised if it was below 100% speedup.

• At every point you mention, errors will be propagated into the system, not to mention bit flipping errors which will become even more significant as your machine sizes descend to the quantum limit. Also, what about the halting problem? This is programming as fantasy, even if this is not a halting problem, how can you have any faith in the answer? Apr 1 at 16:45

## Yes, but it has side effects

1. If you have a wormhole and let one end travel on a relativistic round trip, you will get a wormhole connecting the time-dilated end in the future with the "stationary" end in the "present" - a time machine. Using CTC and information from the future for hypercomputation is trivial. Sadly, wormholes might just not exist in this universe, and if they do, CTCs might be disallowed.

2. a Malament–Hogarth spacetime describes a (general) relativistic configuration that allows (potentially) for infinite computational task to be carried out in a finite observer's time. You set up the computer on a worldline that lies completely in your past, receive a signal from there after the sufficient number of computational steps has been taken (and if you never get a signal, you know that the machine carried out an (countably) infinite amount of steps without finding the solution or whatever). Unfortunately, in practical terms, you probably have to drop the Earth into a black hole to achieve this. Nevertheless, the coolness of having infinite computational power likely outweighs the disadvantages.

• Notes on the MH solution: a Kerr black hole looks like it can be used for hypercomputation in this way but a) you can't perform an infinite amount of computation in a black hole because the things evaporate in a finite length of time (and even extremal charged black holes will ingest oppositely charged particles and be neutralised in a finite length of time) and b) readout is performed by crossing the inner event horizon which in the absense of FTL travel is a one-time trick and the results can't be communicated to the rest of the universe. Apr 1 at 9:12
• Slightly less extreme: an impatient civilization could orbit a (probably rather large) black hole very close to the event horizon, with production, computation and observation moved to a more distant orbit. Just, uh, avoid building any skyscrapers, I suppose. Apr 1 at 9:39
• @Starfish Prime Can you weasel your way around this by keeping an extremal black hole stored somewhere until the universe is so old that no charges exist in your light comes to cancel the extremal parameters. I think I have a new terminal goal for the human species. Apr 2 at 19:34
• @alessandro I don't think that's a thing you can guarantee except in a universe undergoing accelerating expansion. We may not live in one of those, and even if we do there's an outside chance that the dark energy driving the expansion could evaporate black holes. I could easily be wrong, though. Apr 2 at 20:42

In a fashion yes, but not really, and you're really not going to like it.

Time dilation effects are caused by gravity as well as speed & gravity effects reduce with distance.

The higher up a mountain you are the faster time flows compared to elsewhere on the planet.

Put it in space (the further from any large bodies the better) & it's even faster.

You're only going to get a small boost this way though.

So park the Earth in really close orbit around a black hole at the same time & that slows everything down for everyone on Earth compared to your space computer, the closer the orbit the faster it has to be to avoid falling in so you get your relativistic effects of speed at the same time.

The added bonus of course is we can then watch the heat death of the universe unfolding around us in apparent (to us) real time, should be interesting.

• The restaurant at the end of the universe. Apr 1 at 12:06
• By the standards of this website, it would be reasonable to just position the computer high up some kind of "gravity tower" (close to a white hole or whatever). Apr 1 at 18:40
• @ShapeOfMatter OK, I've taken the time to actually read up on white holes properly (deleting other comments on them as they're now excess to requirements) // they're not theorised to 'spew time' // you've taken the 'opposite of a black hole' bit & run with it in the wrong direction // if a white hole can exist in this universe it will spew matter out // so time will be just the same as anywhere in deep space & maybe a bit slower than a completely empty bit of space because of time dilation from that matters mass. Apr 5 at 21:39

The energy required to accelerate a 100 metric ton mass to 99.995% of c is about $$8.9\times10^{23}J$$, which is about 1000 times our yearly energy consumption. I'd wager that for 1000x our current GDP, you can build a pretty big and powerful computer instead.

If you figure this out, you have solved P v NP

This would no longer be an old joke:

Humor: Einstein and Lorentz Play Marbles

Einstein begins, “You know, Hendrik, people say we think so much alike we must be twins, but we are obviously different ages.” Lorentz responds, “Yeah, I know, it sort of a twin paradox – I think Siggie started that one. Forget it, let’s play marbles.” Lorentz said, “Here’s the rules: From a 50/50% mix of red and blue marbles we each have to put the blue marbles in a blue container and the red marbles in a red container.” Einstein responded, “I’ve done something like this before, and I noticed I get worse and worse as the number of items to sort gets larger and larger.”

Being the mathematicians they are, they decided to give each other a 50/50% chance of winning. That meant doing some preliminary games to develop a handicap – like in golf. First Lorentz tried it. Given 2 marbles to sort, he completed the task in 2 seconds. 4 marbles, 4 seconds; 10 marbles, 10 seconds, etc. Now, for Einstein: 2 marbles, 2 seconds; 4 marbles, 24 seconds; 10 marbles 3628800 seconds, etc. Lorentz said, “Looks like I scale linearly as x, as the number of marbles, increase … But, wow, Albert, you scale as a factorial, x!”. They both realized the handicap was x! / x, with Albert’s nonpolynomial rate (x!) on top of Hendrik’s simple polynomial rate (x).

Einstein said, “I think I know how to normalize for our respective handicap using a new vehicle I just invented that runs on an E=mc^2 engine and dilates time (t) to t’ based on division of t by that equation you just discovered with ( 1 – (v^2 / c^2))^-0.5. We will have to neglect F = ma because it will be crushing and W = fd because of the consequential heat at the launch site.”

Lorentz agreed and added, “Let’s play for the best rate, after normalization, because I don’t want to do all the integrals for total velocity and time!” Einstein fret that he had problems naming the vehicle, “I found that Folks-Wagon is taken, so I called it a You-Van. In fact, I’ll ride first because you are so slow.” They worked out the math and found the necessary velocity for the handicap to sort 100 marbles:

t’ = t (( 1 – (v^2 / c^2 ))^-0.5) solve for v, with c = 1: v = ( t’^2 – t^2)^0.5) / t’ substitute the scaling factors: v = (((x!)^2 – x^2)^0.5) / (x!) enter actual numbers: v = (((100!)^2 – 100^2)^0.5) / (100!)

Lorentz looked again and said, “Too bad Cook and Levin haven’t been born yet!” Einstein added, “Oops, we have to wait for Wolfram, too, as we need a lot of precise digits for this calculation. Another day …”

In other words: As Velocity Approaches Light Speed, P Becomes Equivalent to NP for Computations Using Zero-Mass Particles

• NP is nondeterministic polynomial, not non-polynomial.
– Ray
Apr 1 at 20:31
• Yes, the problem here is not time but number of computation steps - as in Big O notation, but for sci-fi engineering, I think time and steps are the ~ same. BTW, the WP article is unreadable. Apr 1 at 23:35

If you know how to contain a black hole, you shouldn't even need the Super Hyper Extravaganza Space Ship ©™. You could just make a black hole, contain it, park the computer near it, and due to the time dilation from the black hole, the equation could be solved relatively quickly.

• "the equation could be solved [really slowly]." fixed it for you, black holes slow time, so, more time passes for everyone outside it's influence, so the computer will take longer to do the calculations, relatively. Apr 1 at 14:10
• How about, then say you park earth around the black hole in the habitable zone of the accretion disk? Apr 1 at 15:00
• @TheMadmanandtheFool - several people have proposed putting Earth nearer the event horizon than the computer in their answers, yes. Apr 1 at 16:08
• @Pelinore Thanks for the correction. This is venturing into theory here, but you could replace the black hole with a "white hole" instead. Apr 5 at 13:36
• @randominternetperson OK, I've taken the time to actually read up on white holes properly (deleting other comments on them as they're now excess to requirements) // they're not theorised to 'spew time' // you've taken the 'opposite of a black hole' bit & run with it in the wrong direction // if a white hole can exist in this universe it will spew matter out // so time will be just the same as anywhere in deep space & maybe a bit slower than a completely empty bit of space because of time dilation from that matters mass. Apr 5 at 21:33


text:
FANDOM

9,304 Pages

 Current season: 2020 Atlantic usercane season

A usercane is a type of hypothetical hurricane issued to most users of Hypothetical Hurricanes Wiki that meet certain requirements. Usercanes are tracked like real hurricanes, but are much longer lived than hurricanes. Strong usercanes often last several months, sometimes even years. Meanwhile, other weak usercanes dissipate after a day or two. They were first classified by the BNWC in December 2015, and advisories began to be issued for them the next month. The BNWC established the National Usercane Center (NUC) in early 2016, which issued advisories on usercanes, before being temporarily discontinued in September 10, 2016. Other weather centers, such as the HOWC, HTMC, SMWC, CDMC, FMC, KMC and ICON (occasionally) track usercanes. Of those, some such as the FMC, KMC, HTMC, SMWC, CDMC, and ICON have dedicated usercane tracking branches. An average usercane season according to the NUC (2010-2017) features 17.1 named storms, 7.1 usercanes and 5.8 major usercanes, while an average usercane season according to ICON (2010-2016) features 14 named storms, 7.2 hurricanes and 6.1 major hurricanes.

Defining usercanes and naming criteria

Usercanes were first recognized by the BNWC in November 2015, but a system of classification was not made at the time. Due to HHW having five different primary user rights ranks, the "usercane scale" was created. The BNWC eventually established its own specialized usercane branch known as the National Usercane Center (NUC) in May 2016.

Fully Tropical Usercanes

Role Classification
New editor Tropical depression
User Tropical storm
Autopatrolled user Severe tropical storm
Chat moderator (OR rollback without chat moderator rights) Category 1 usercane
Rollback (with chat moderator rights) Category 2 usercane
Bureaucrat Category 5 usercane
Experienced bureaucrat Category 6 usercane (unused)

The NUC will issue advisories on a usercane if the following requirements are met for the user:

• The user has at least 100 edits (former requirements: 5 edits before January 1, 2017, 25 edits from January 1, 2017 to January 1, 2019), AND
• The user has never been on HHW before.

The NUC first used this system with Tropical Storm Destiny of 2016 (which was later declassified), and the procedure was later used throughout the season. However, the HurricaneOdile Weather Center (HOWC) recognizes all users with at least 5 edits as usercanes. Beginning on January 1, 2017, NUC would not initiate advisories unless the user had at least 25 edits. These limits were further revised upwards two years later, and as of January 1, 2019, users are required to have at least 100 edits to be classified.

Subtropical usercanes

A usercane is considered to be "subtropical" if one of the five conditions are met:

• The user meets the requirement for classification as a usercane, but does not intend to join HHW full-time. A major case of this was Hurricane Floyd in 2015, which later grew into a powerful fully tropical category 5 storm;
• The user is blacklisted from user rights;
• The user is semi-retired;
• The user has planned to go inactive for a long period of time;
• The user is slowly coming out of a retired state.

If the user no longer meets one of the five requirements, their usercane becomes fully tropical. Subtropical usercanes very rarely grow into Category 5 intensity whilst subtropical; a very rare case of this was Hurricane BeoBlade in September 2015 during the burst of usercane activity that led to the formation of many intense usercanes.

Extratropical usercanes

When a user retires from HHW, their usercane becomes extratropical. A notable case of this was Hurricane Steve in May 2015, which turned extratropical (which later regained subtropical characteristics one year later).

Remnant lows/post-tropical usercanes

When a user disappears from HHW randomly, or they have stopped editing for a period of time without officially retiring or semi-retiring, they either: degenerate into a remnant low, or turn post-tropical. A notable case of this was Hurricane Jack in 2016, which degenerated into a remnant low in February before reforming in March.

Invests

This system has been officially deprecated since January 1, 2019, and will not be used by the National Usercane Center.

From January 1, 2017, to January 1, 2019, users were designated as "invests" if they meet one of the following two requirements:

• 5 to 24 edits;
• or 1-5 edits AND a chat appearance.

Prior to January 1, 2017, users were designated as "invests" if they met one of the following two requirements:

• 1 to 5 edits;
• or 0 edits AND a chat appearance.

Landfalls

When a user gets banned, they are said to have made landfall. In recent years there has been a significant uptick in landfalling usercanes; notable landfalling usercanes include Puffle, Nkechinyer, and Douglas, all of which made landfall at category 5 intensity. The most recent usercanes that made landfall was Tropical Storm Harris of the 2018 season, which was unexpectedly absorbed by Usercane Hype in mid-March.

Climatology

Total and average number of
tropical userstorms by month (2010-2017)
Month Total Average per year
January 10 1.3
February 8 1.0
March 4 0.5
April 11 1.4
May 9 1.1
June 15 1.9
July 11 1.4
August 10 1.3
September 18 2.3
October 21 2.6
November 15 1.9
December 9 1.1

The Atlantic usercane season has no seasonal bounds; it runs from January 1 to December 31. There have been a total of 141 tropical userstorms recorded from 2010 to 2017, with an average of about 17.6 per season. Userstorms and usercanes have been recorded in all months. However, some months are more active than others. The most active month, on average, is October, featuring 2.6 storms per year on average. The least active month, on average, is March, averaging only a storm every other year. The season does not have a distinct peak, though it tends to be more active in the summer and fall months during the Atlantic hurricane season.

Usercane ACE

The Accumulated Cyclone Energy (ACE) of a usercane is calculated by summing the squares of a usercane's wind speed in knots at one-week intervals, divided by 10000 (e.g. 40 mph in knots is 35 kts. 35kts multiplied by 35 kts equals 1225. 1225 divided by 10000 equals 0.1225, which is the usercane's wind speed at a specific time). To remain consistent, wind speeds are measured on Fridays at 00:00 UTC. Subtropical cyclones are included, but not systems with winds under 34 kt (39 mph). Usercane Hype so far has the most ACE of all usercanes.

The formula below is used to calculate a usercane's ACE at weekly intervals. "vmax" is the estimated sustained wind speed in knots.

$\text{ACE} = 10^{-4} \sum v_\max^2$

Category 5 usercanes

The following usercanes attained Category 5 intensity for at least one advisory. So far, as of June 2018, there have been 26 known category 5 usercanes. Note: This list may be outdated. They are listed as follows:

• Sjmaven (2010) - 180 mph, 895 mbar
• Dylan (2010) - 165 mph, 928 mbar
• Hype (2013) - 280 mph, 797 mbar
• Ryne (2013) - 175 mph, 902 mbar
• Dwight (2013) - 160 mph, 929 mbar
• Douglas (2014) - 160 mph, 966 mbar
• Cardozo (2014) - 160 mph, 964 mbar
• Bumblebee (2014) - 165 mph, 931 mbar
• Layten (2014) - 175 mph, 916 mbar
• EF5 (2015) - 160 mph, 925 mbar
• Puffle (2015) - 175 mph, 911 mbar
• Odile-Roussil (2015) - 160 mph, 920 mbar
• IceCraft (2015) - 160 mph, 964 mbar[note 1]
• Nkechinyer (2015) - 165 mph, 904 mbar
• Austin (2015) - 160 mph, 936 mbar
• BeoBlade (2015) - 160 mph, 970 mbar[note 2]
• Bob (2015) - 245 mph, 819 mbar
• Floyd (2015) - 235 mph, 834 mbar
• Collin (2015) - 160 mph, 919 mbar
• Anthony (2015) - 200 mph, 877 mbar
• Keranique (2016) - 165 mph, 921 mbar
• Darren (2016) - 165 mph, 918 mbar
• Garfield-Vile-Porygon (2016) - 240 mph, 819 mbar
• Brick (2016) - 160 mph, 930 mbar
• James (2016) - 210 mph, 865 mbar
• RAM-Akio (2016) - 180 mph, 895 mbar
• Farm (2016) - 160 mph, 894 mbar

For a complete list of category 5 and category 4 usercanes, see here (please note these estimates are by the ICON Usercane Center and may or may not be official):

Usercane seasons

For a complete list of usercane seasons, go here.

Usercane records

For a condensed list of usercane records, go here.

Size

• Less than 20 miles - Midget
• 20-100 miles - Very Small
• 101-200 miles - Small
• 201-350 miles - Medium
• 351-500 miles - Large
• 501-800 miles - Very Large
• 801+ miles - Giant

Notes

1. IceCraft was a very small usercane that attained category 5 intensity while subtropical (it did peak as a C3 while fully tropical)


text:
## Q1 when a scalar quantity multiplied with a vector quantity, then the direction of the product is

• a) Opposite direction to vector quantity
• b) Same direction to vector quantity
• c) Perpendicular to the direction of vector quantity
• d) None

• b) Same direction to vector quantity

## Q2  when a vector quantity velocity is multiplied with a scalar quantity time then a new product form is

• a) Linear momentum
• b) Velocity vector
• c) Distance
• d) Displacement

• d) Displacement

• a) True
• b) False

• b) False

## Q4 When two vectors in the same direction are added, the magnitude of resulting vector is equal to _______

• a) Sum of magnitudes of the vectors
• b) Difference of magnitudes of the vectors
• c) Product of magnitudes of the vectors
• d) Sum of the roots of magnitudes of the vectors

• a) Sum of magnitudes of the vectors

## Q5  On adding two vectors we get _____

• a) A vector
• b) A scalar
• c) A number
• d) An operation

• a) A vector

• a) True
• b) False

• b) False

• (a) P + Q
• (b) P – Q
• (c) P / Q
• (d) Q / P

• (b) P – Q

## Q8 The resultant of two equal vectors P making an angle θ is given by :-

• a) 2PSin\frac{θ}{2}
• b) PSin\frac{θ}{2}
• c) PCos\frac{θ}{2}
• d) 2PCos\frac{θ}{2}

• d) 2PCos\frac{θ}{2}

## Q9.  The resultant of two forces each equal to P and acting at right angles is

• a) \sqrt{\frac{P}{2}}
• b) \sqrt{\frac{2}{P}}
• c) \sqrt 2{P}
• d) None of these

• c) \sqrt 2{P}

• a) 1
• b) 0
• c) 90
• d) 180

• b) 0


text:
# Custom Graphs¶

There may be times when you want to do parallel computing but your application doesn’t fit neatly into something like Dask Array or Dask Bag. In these cases, you can interact directly with the Dask schedulers. These schedulers operate well as standalone modules.

This separation provides a release valve for complex situations and allows advanced projects to have additional opportunities for parallel execution, even if those projects have an internal representation for their computations. As Dask schedulers improve or expand to distributed memory, code written to use Dask schedulers will advance as well.

## Example¶

As discussed in the motivation and specification sections, the schedulers take a task graph (which is a dict of tuples of functions) and a list of desired keys from that graph.

Here is a mocked out example building a graph for a traditional clean and analyze pipeline:

def load(filename):
...

def clean(data):
...

def analyze(sequence_of_data):
...

def store(result):
with open(..., 'w') as f:
f.write(result)


text: The HydrideAction system is used to create the set of kernels and materials required to track the concentration evolution of hydrogen as soluble hydrogen and as hydride in the cladding. See the description, example use, and parameters on the Cladding Hydride action page.


text:
# Shift strings Circular left and right in JavaScript

JavascriptWeb DevelopmentFront End TechnologyObject Oriented Programming

We are required to write a JavaScript function that takes in three arguments, first is a string, say str, then we have two numbers, lets say m and n. The numbers m and n basically specify the amount of leftShifts and rightShifts respectively.

We define these terms like such −

Left Shift − A single circular rotation of the string in which the first character becomes the last character and all other characters are shifted one index to the left.

For example, abcde becomes bcdea after one left shift and cdeab after two left shifts.

Right Shift − A single circular rotation of the string in which the last character becomes the first character and all other characters are shifted to the right.

For example, abcde becomes eabcd after one right shift and deabc after two right shifts.

So, basically our function should perform the specified number of left and right shifts and then finally return the resultant string.

## Example

The code for this will be −

const str = 'abcdef';
const getShiftedString = (str, leftShifts, rightShifts) =>
shiftByAmount(shiftByAmount(str, leftShifts), −rightShifts);
// helper function
// negative amount shifts to right
// positive amount shifts to left
const shiftByAmount = (str, leftShifts) => {
leftShifts = leftShifts % str.length;
return str.slice(leftShifts) + str.slice(0, leftShifts);
};
console.log(getShiftedString(str, 3, 2));

## Output

And the output in the console will be −

Bcdefa
Published on 25-Nov-2020 12:13:13


text:
# Homework Help: Question on capacitance and electric fields

1. Apr 1, 2012

### daviddeakin

Consider a thin parallel plate capacitor of an area of of 2.0x10^-4 metres squared, with
a thickness of 1.2x10^-4 metres. The top and bottom thirds of the capacitor are filled with a dielectric material with a relative dielectric permittivity εr1=4, and the central third, with another material with εr2=8 (so it's a triple layer sandwich) .The voltage on the capacitor is 3V.

Calculate the electric flux densities and the electric field magnitudes in all three parts of the device. State any assumptions used.

We can treat this as three capacitors in series, each with a plate separation of 4x10^-5 m. The upper and lower capacitors are:
C=εA/d = 4 x 8.85x10^-12 / 4x10^-5 = 117pF
The middle capacitor is:
C=εA/d = 8 x 8.85x10^-12 / 4x10^-5 = 354pF

But I don't know how to complete the question. For a single capacitor I would find the charge: Q=CV, then find the electric field from: E = D/ε = Q/Aε

But in this case I don't know what the voltage on each capacitor is. Is it simply one third of the voltage across the whole device? Also, I must be going about this in the wrong way, because the NEXT part of the question is:

Calculate the charge on the plates and the capacitance of the device.

The total capacitance is clearly:
C = [1/C1 + 1/C2 + 1/C3]^-1 = 50.2pF

But the way I'm attempting it already gives the charge before the second part of the question!

(Also, is there a way to do superscripts on this forum?)

2. Apr 1, 2012

### Staff: Mentor

Hi daviddeakin, Welcome to Physics Forums.

I think you forgot to include the plate area in your calculations above. I see the numbers for permittivity and distance, but not the area.
Since the capacitors are in series, what can you say about the charge on each?
Try the X2 icon in the the edit window header, or use the LaTex syntax (you'll need to learn about LaTex embedding tags).

The person who created the problem may have had a particular strategy in mind, but so long as you get to the correct solution by valid steps don't worry about the order that the parts get answered.

3. Apr 1, 2012

### daviddeakin

Hi Gneill,

I have difficulty getting to grips with charge! If the top plate has some positive charge, then the bottom plate must have some equal negative charge. But the ones in between I'm not sure about! Do they have similar charge, alternating in sign, or simply zero charge?

If it is zero, then the electric field in the central capacitor would be zero, which sounds wrong somehow...

The plate area was 2.0x10^-4 metres squared, BTW.

4. Apr 1, 2012

### Staff: Mentor

Current is always the same for all components connected in series. So if charge Q is moved onto the top plate of the stack, charge Q must move off of the next plate in line and onto the plate following that, and so on down the line. The net result is that all capacitors in a series connection end up with the same charge (+Q on one plate, -Q on the other).

5. Apr 2, 2012

### daviddeakin

Intriguing! So the top and bottom capacitors are:
C=εA/d = 4 x 8.85x10-12 x 2.0x10-4 / 4x10^-5 = 177pF
The middle capacitor is:
C=εA/d = 8 x 8.85x10-12 x 2.0x10-4 / 4x10^-5 = 354pF

The total capacitance is: 70.8pF

Charge on the top and bottom plates is:
Q = CV = 70.8pF x 3V = 212.4pC
which must now be the same for all of the capacitors.

The electric fields in the top and bottom capacitors are:
E = Q/εA = 212.4pC / (4 x 8.85x10^-12 x 2.0x10-4 ) = 30kV/m
And for the middle capacitor:
E = Q/εA = 212.4pC / (8 x 8.85x10^-12 x 2.0x10-4 ) = 15kV/m

The flux density is assumed uniform and will be the same for all the capacitors:
D = Q/A = 212.4pC / 2.0x10-4 = 1.1 uC/m2

Thanks!

6. Apr 2, 2012

### Staff: Mentor

Looks good, except you might want to check whether they want charge density (Q/A) or electric flux density ($\Phi_E$) for that last bit. They are different beasts.

7. Apr 2, 2012

### daviddeakin

Is ($\Phi$) the flux in coulombs? If so then ($\Phi_E$) would be the force between the plates wouldn't it?

8. Apr 2, 2012

### Staff: Mentor

Charge is given in coulombs. Flux is in volt-meters (Vm).

Remember Gauss' Law where the electric flux crossing the boundary of an enclosed space ("Gaussian Surface") is summed up in order to determine the enclosed charge?

$$\Phi_E = \oint_s \! E \cdot dA = \frac{Q_s}{\epsilon_r\epsilon_o}$$

9. Apr 2, 2012

### daviddeakin

Hmm, I've been learning from a book which says:

"Gauss' law states that the flux through any closed surface is equal to the charge enclosed by that surface."

So I have been using flux in coulombs... What am I missing?

10. Apr 2, 2012

### Staff: Mentor

I think you're missing the bit at the end of that sentence that goes "...divided by the permittivity."

Charge is in Coulombs. Flux is in Volt-meters. The idea is that flux is what charges produce that describes the electric field. It is similar in concept to magnetic flux lines.

You have a couple of choices of method for calculating the flux here. The field is constant over the area of the plates of the capacitors so you can multiply E*A, which is the same as the performing the surface integral I showed above, or you can divide the plate charge by the permittivity for the given capacitor.

11. Apr 2, 2012

### daviddeakin

There's definitely nothing else at the end of sentence! The whole book (and indeed my lecture course) follows the same lines- flux is in coulombs. See Wiki, for example:

http://en.wikipedia.org/wiki/Statcoulomb
"An electric flux (specifically, a flux of the electric displacement field D) has units of charge: statC in cgs and coulombs in SI."

Perhaps physicists and electronic-ists have different conventions...

12. Apr 2, 2012

### Staff: Mentor

Ah. Statcoulombs. That's a unit system that handles things a bit differently. That's not the system that typically used for most courses. I rarely run across it at all.

Note the statement of Gauss' Law here: http://hyperphysics.phy-astr.gsu.edu/hbase/electric/gaulaw.html

Also here: http://en.wikipedia.org/wiki/Gauss%27s_law

13. Apr 2, 2012

### daviddeakin

I don't think it's statcoulombs- they're for the cgs system. Note that it says the flux is in coulombs for the SI system. I can see this is going to keep me awake for a while.

EDIT:
I emailed my lecturer about it, and he said:

"It's the same. Intergral of _D_ is charge and integral of _E_ is charge/epsilon.
Remember that _D_= epsilon_E_ by definition."

I can't decide if that helps...

Last edited: Apr 2, 2012


text:
# Find the derivatives. by differentiating the integral directly. \frac{d}{d0}\int_{0}^{\tan 0}\sec^{2}ydy

Find the derivatives.
by differentiating the integral directly.
$\frac{d}{d0}{\int }_{0}^{\mathrm{tan}0}{\mathrm{sec}}^{2}ydy$
You can still ask an expert for help

• Questions are typically answered in as fast as 30 minutes

Solve your problem for the price of one coffee

• Math expert for every subject
• Pay only if we can solve it

Laaibah Pitt


text:
# Bayes with conditional independence

I have a problem that I can't work out

I've two conditional independent A,B such as

$P(A,B|C) = P(A|C)P(B|C)$

Now I've to find posterior formula for:

$P(C | A,B)$, now what I got was pretty straigthforward application of bayes:

$\frac{P(B|C)P(A|C)P(A)}{P(A\cap B)}$

With few variants (e.g. get an intersection on numerator)

but I can't get the lecturer solution that is:

$\frac{P(B|C)P(C|A)}{P(B|A)}$

Any help?

(note is not homework, but self studying on some pdfs)

Note that from the assumption you get: $\mathbb P(B|A,C)=\mathbb P(B|C)$. Therefore: $$\mathbb P(C|A,B)\mathbb P(B|A)=\mathbb P(B,C|A)=\mathbb P(C|A)\mathbb P(B|C,A)=\mathbb P(C|A)\mathbb P(B|C).$$


text:
시간 제한메모리 제한제출정답맞힌 사람정답 비율
2 초 512 MB202947144.099%

## 문제

The cow mega-city Bovinopolis is redistricting! -- always a contentious political process between the two major cow breeds (Holsteins and Guernseys) living there, since both breeds want to make sure they retain sufficient influence in the Bovinopolis government.

The greater metropolitan area of Bovinopolis consists of a line of $N$ pastures ($1 \leq N \leq 3 \cdot 10^5$), each containing a single cow, which is either a Holstein or a Guernsey.

The government of Bovinopolis wants to divide the greater metropolitan area into some number of contiguous districts, so that each district contains at most $K$ pastures ($1 \leq K \leq N$), and every pasture is contained in exactly one district. Since the government is currently controlled by Holsteins, they want to find a way to redistrict which minimizes the number of Guernsey-majority or tied districts (a district is tied if the number of Guernseys equals the number of Holsteins).

A concerned coalition of Guernseys is trying to figure out how much damage might be done by the government's redistricting. Help them figure out the worst-case minimum number of districts which are either Guernsey-majority or tied.

## 입력

The first line contains a two space-separated integers $N$ and $K$. The second line contains a string of length $N$. Each character is either 'H' or 'G', for Holstein or Guernsey.

## 출력

Please output the minimum possible number of districts that are Guernsey-majority or tied.

## 예제 입력 1

7 2
HGHGGHG

## 예제 출력 1

3


text:
# The inverse of a function

1.  Intro to inverse functions (9:05)  For , Sal finds
2. Inputs and outputs of inverse functions (6:18)  For a function defined by a table, find , , , , .
3.  Graphing the inverse of a  linear function (2:17)
4. *  Practice: Type of problem: Given the graph of a function , find the value of .
5.  Finding inverse functions: quadratic (7:12) Find the inverse of for .
6.  Finding inverse functions: rational (7:01) Find the inverse of  .
7. *  Practice: Type of problem: What is the inverse function of ?


text:
Article Contents
Article Contents

# Empirical results for pedestrian dynamics and their implications for modeling

• The current status of empirical results for pedestrian dynamics is reviewd. Suprisingly even for basic quantities like the flow-density relation there is currently no consensus since the results obtained in various empirical and experimental studies deviate substantially. We report results from recent large-scale experiments for pedestrian flow in simple scenarios like long corridors and bottlenecks which have been performed under controlled laboratory conditions that are easily reproducible. Finally the implications of the unsatisfactory empirical situation for the modeling of pedestrian dynamics is discussed.
Mathematics Subject Classification: Primary: 90B20; 62-07; Secondary: 91C05,60-02.

 Citation:


text:
# Isotropic Volumetric Swelling for FeCrAl

Computes a volumetric strain to account for irradiation induced swelling of FeCrAl alloys used for cladding

warning:Deprecated Solid Mechanics Material

The functionality of this solid mechanics material is being replaced in the TensorMechanics system by FeCrAlVolumetricSwellingEigenstrain.

## Description

The VSwellingFeCrAl model computes a volumetric strain to account for irradiation induced swelling of FeCrAl alloys used for cladding.

It is expected that FeCrAl alloys will be subjected to irradiation induced swelling due to their cubic crystal structure. As an approximation for the swelling of FeCrAl alloys a simplistic model provided in Terrani et al. (2016) has been implemented in Bison. The estimated swelling rate is 0.05% per dpa. Using the same conversion factor as suggested above for irradiation creep (1 10 n/m = 0.9 dpa) the volumetric swelling strain rate is given by: (1) Integrating over time the volumetric swelling is given by (2) where is the fast neutron fluence given in n/m.

## Example Input Syntax

[./swelling]
type = VSwellingFeCrAl
block = '1 2 3 4 5 6 7'
fast_neutron_fluence = fluence
swelling_scalef = 1.0
[../]
(test/tests/fecral/swelling/swelling.i)

## Input Parameters

• fast_neutron_fluenceCoupled fast neutron fluence

C++ Type:std::vector

Description:Coupled fast neutron fluence

• boundaryThe list of boundary IDs from the mesh where this boundary condition applies

C++ Type:std::vector

Description:The list of boundary IDs from the mesh where this boundary condition applies

• computeTrueWhen false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the Material via MaterialPropertyInterface::getMaterial(). Non-computed Materials are not sorted for dependencies.

Default:True

C++ Type:bool

Description:When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the Material via MaterialPropertyInterface::getMaterial(). Non-computed Materials are not sorted for dependencies.

• blockThe list of block ids (SubdomainID) that this object will be applied

C++ Type:std::vector

Description:The list of block ids (SubdomainID) that this object will be applied

• swelling_scalef1Scale factor on the swelling of the fuel

Default:1

C++ Type:double

Description:Scale factor on the swelling of the fuel

### Optional Parameters

• enableTrueSet the enabled status of the MooseObject.

Default:True

C++ Type:bool

Description:Set the enabled status of the MooseObject.

• use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Default:False

C++ Type:bool

Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

• control_tagsAdds user-defined labels for accessing object parameters via control logic.

C++ Type:std::vector

Description:Adds user-defined labels for accessing object parameters via control logic.

• seed0The seed for the master random number generator

Default:0

C++ Type:unsigned int

Description:The seed for the master random number generator

• implicitTrueDetermines whether this object is calculated using an implicit or explicit form

Default:True

C++ Type:bool

Description:Determines whether this object is calculated using an implicit or explicit form

• constant_onNONEWhen ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeSubdomainProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped

Default:NONE

C++ Type:MooseEnum

Description:When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeSubdomainProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped

• output_propertiesList of material properties, from this material, to output (outputs must also be defined to an output type)

C++ Type:std::vector

Description:List of material properties, from this material, to output (outputs must also be defined to an output type)

• outputsnone Vector of output names were you would like to restrict the output of variables(s) associated with this object

Default:none

C++ Type:std::vector

Description:Vector of output names were you would like to restrict the output of variables(s) associated with this object

## References

1. K. A. Terrani, T. M. Karlsen, and Y. Yamamoto. Input correlations for irradiation creep of FeCrAl and SiC based on in-pile Halden test results. Technical Report ORNL/TM-2016/191, ORNL, May 2016.[BibTeX]


text:
# Consider the following amplitude modulated signal: s(𝑡) = cos(2000 𝜋𝑡) + 4 cos(2400 𝜋𝑡) + cos(2800 𝜋𝑡).The ratio (accurate to three decimal places) of the power of the message signal to the power of the carrier signal is ________.

This question was previously asked in
GATE EC 2018 Official Paper
View all GATE EC Papers >

## Answer (Detailed Solution Below) 0.25

Free
CT 1: Ratio and Proportion
2846
10 Questions 16 Marks 30 Mins

## Detailed Solution

Concept:

For a single tone sinusoidal signal, the expression for amplitude modulated wave is given by:

$${x_{AM}}\left( t \right) = {A_c}\left( {1 + {m_a}\cos {\omega _m}t} \right)\cos {\omega _c}t$$

$${A_c}\cos {\omega _c}t + \frac{{{A_c}{m_a}}}{2}\cos \left( {{\omega _c} + {\omega _m}} \right)t + \frac{{{A_c}{m_a}}}{2}\cos \left( {{\omega _c} - {\omega _m}} \right)t$$

Calculation:

Comparing the given expression with the standard expression, the given AM signal can be written as:

$${x_{AM}}\left( t \right) = 4\left( {1 + \frac{1}{2}\cos {\omega _m}t} \right)\cos {\omega _c}t$$

$$So,\;{m_a} = \frac{1}{2}\;and\;{A_c} = 4$$

The modulation index is given by;

$${m_a} = \frac{{{A_m}}}{{{A_c}}} = \frac{1}{2}$$

$${A_m} = \frac{{{A_c}}}{2} = \frac{4}{2} = 2$$

Power of the message signal is, therefore:

$${P_m} = \frac{{A_m^2}}{2} = \frac{4}{2} = 2\;W$$

Power of the carrier signal:

$${P_c} = \frac{{A_c^2}}{2} = \frac{{{4^2}}}{2} = 8\;W$$

So, the required ratio of the message power to the carrier power:

$$\frac{{{P_m}}}{{{P_c}}} = \frac{2}{8} = \frac{1}{4} = 0.25$$


text:
# Formula for Goldman Lie bracket of surface

Let $\Sigma_{g}$ be a closed oriented surface of genus $g$, Goldman defined a Lie algebra structure on the free module generated by the free homotopy classes of loops on $\Sigma_{g}$. Roughly speaking, the Lie bracket is defined via intersection and concatenation of loops. In detail, see his paper Invariant functions on Lie groups and Hamiltonian flows of surface group representations .

I want to know that are there any formulas to compute this Lie bracket for small nonzero $g$? For example, what is the Goldman Lie algebra of torus? Any help or any references would be very appreciated.

I would recommend looking at the work of Moira Chas to start.

Here are two interesting papers of hers to read:

The Goldman bracket and the intersection of curves on surfaces.

Combinatorial Lie bialgebras of curves on surfaces

She even has an app on her website that computes the bracket for you: Goldman Bracket.

How to use the app: in the first box you input the relation defining the surface group (so for a torus abAB or a pair-of-pants abc). The next two boxes are for words in the surface group representing (free) homotopy classes of closed curves. For the syntax, lower case letters like a,b,c are for generators of the surface group and capital letters like A,B,C are for the inverses of a,b,c, respectively. I believe the app expects cyclically reduced words.

• Thanks a lot. By the way, do you know how to use her app? I am quite confused about the inputs. – Yining Zhang Jun 7 '18 at 2:45
• @YiningZhang Why don't you ask her? – Igor Rivin Jun 7 '18 at 4:11


text:
# Let A, B, and C be vectors in R3...prove r lies in a plane

Tags:
1. Oct 19, 2016

### Sho Kano

1. The problem statement, all variables and given/known data
$\vec { \dot { r } } =(t+1)\vec { A } +(1-sint)\vec { B } \quad \vec { r(0) } =\vec { C }$
a. Find an equation of the tangent line to the curve at $\vec { r(0) } =\vec { C }$.
b. Use a definite integral to find $\vec { r(t) }$
c. If $A$ and $B$ are non parallel, prove $\vec { r(t) }$ lines in a plane.

2. Relevant equations

3. The attempt at a solution
a. $\vec { T } =\vec { C } +t(\vec { A } +\vec { B } )$
b. $\vec { r(t) } =\frac { 1 }{ 2 } \vec { A } { t }^{ 2 }+\vec { A } t+\vec { B } t+\vec { B } cost-\vec { B } +\vec { C }$
c. How can I use an equation of a plane to prove this part?

2. Oct 19, 2016

### andrewkirk

A vector equation of a plane through $\vec C$ is
$$\{\vec C+s\vec A +t\vec B\ :\ s,t\in\mathbb R\}$$
where $\vec A,\vec B$ are two non-parallel vectors.

The equation you have derived in (b) can be expressed in that format, hence all the points in the curve lie in the plane defined by that formula.

If you have been given a different form for the vector equation of a plane, a few more steps may be necessary.

3. Oct 19, 2016

### Sho Kano

Oh I haven't seen that equation before. The one we were taught is $\vec { N } \cdot (\vec { P } -\vec { { P }_{ 0 } } )=0$, where $\vec { N }$ is normal to $(\vec { P } -\vec { { P }_{ 0 } } )$. I can't figure out where to get $\vec { N }$ from

Where can I find more on that equation? I've tried google already

4. Oct 19, 2016

### andrewkirk

Actually, on reflection, what I gave is a formula for a plane rather than an equation. The question doesn't say whether to use a formula or an equation, but since you've been given the equation you quote in your last post, it's best to use that.

In your equation, the arbitrary point on the plane is $\vec P$, the specified point on the plane is $\vec P_0$ and the normal to the plane is $\vec N$.

So the challenge is to find values for $\vec P_0$ and $\vec N$ such that all points $\vec r(t)$ on the curve satisfy the equation when we substitute them for $\vec P$.

Finding a satisfactory $P_0$ is easy. Given the equation you derived in (b), what is a vector (point) that must be on the plane containing the curve?

Then, to find $\vec N$, how can we write a formula for a vector that is perpendicular to the vector obtained by subtracting $\vec P_0$ from the right hand side of the formula in (b)?

5. Oct 20, 2016

### Sho Kano

not sure if I have the right idea but if the curve does lie in a plane, then then any derivative lies in the same plane as any position. So, their cross product will give the appropriate normal vector. If the curve doesn't lie in a plane, then the dot product will not equal zero when we plug in $r(t)$.
$\vec { \dot { r(0) } } =\vec { A } +\vec { B } \quad \vec { r(0) } =\vec { C } \\ \vec { N } =\vec { r(0) } \times \vec { \dot { r(0) } } =\left( \vec { A } +\vec { B } \right) \times \vec { C } \\ \vec { N } \cdot \left( \vec { r(t) } -\vec { r(0) } \right) =0\\ \left[ \left( \vec { A } +\vec { B } \right) \times \vec { C } \right] \cdot \left( \vec { r(t) } -\vec { C } \right) =0$
when I do the computation above, I end up with $\left( cost-\frac { 1 }{ 2 } { t }^{ 2 }-1 \right) \left( \vec { A } \times \vec { C } \cdot \vec { B } \right) =0$?

6. Oct 20, 2016

### andrewkirk

You have an acceptable answer for $\vec P_0$, but not for $\vec N$.

To work out $\vec N$, you might find it easier to think about the plane that is parallel to the plane of the curve but passes through the origin. If you can find an expression for the normal to that plane, using only $\vec A,\vec B,\vec C$ (and not necessarily all of them) then you can use the same normal for the plane of the curve, since parallel planes have the same normal.

7. Oct 20, 2016

### Sho Kano

Ah, I think I have to sort of "guess" to get the normal vector I tried $\vec { A } \times \vec { B }$ and it worked! So I have to somehow "use" the given information and hope it works.